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 clippingHGMevaluation(input_generator, branches, Plot, reference=None):
for t in range(8, 11):
t = t / 10.0
thresholds = [-t, t]
input_signal = input_generator.GetOutput()
nl_functions = [
nlsp.function_factory.hardclip(thresholds),
] * branches
filter_spec_tofind = nlsp.log_bpfilter(branches=branches,
input=input_signal)
ref_nlsystem = nlsp.HammersteinGroupModel_up(
input_signal=input_signal,
nonlinear_functions=nl_functions,
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))
# sine = sumpf.modules.SineWaveGenerator(frequency=5000.0,phase=0.0,samplingrate=input_signal.GetSamplingRate(),length=len(input_signal)).GetSignal()
sine = sumpf.modules.SweepGenerator(
samplingrate=input_signal.GetSamplingRate(),
length=len(input_signal)).GetSignal()
ref_nlsystem.SetInput(sine)
iden_nlsystem.SetInput(sine)
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=False)
print "SNR between Reference and Identified output for symmetric hardclipping HGM(thresholds:%r): %r" % (
thresholds,
nlsp.snr(ref_nlsystem.GetOutput(), iden_nlsystem.GetOutput()))
def theoretical_evaluation():
puretone_freq = 10000
input_tone = sumpf.modules.SineWaveGenerator(frequency=puretone_freq,
phase=0.0,
samplingrate=sampling_rate,
length=length)
sine = input_tone.GetSignal()
input_tone.SetFrequency(2 * puretone_freq)
sine_2 = input_tone.GetSignal()
input_tone.SetFrequency(3 * puretone_freq)
sine_3 = input_tone.GetSignal()
input_tone.SetPhaseInDegrees(90)
cos = input_tone.GetSignal()
input_tone.SetFrequency(2 * puretone_freq)
cos_2 = input_tone.GetSignal()
input_tone.SetFrequency(3 * puretone_freq)
cos_3 = input_tone.GetSignal()
theoreticl_op_2 = sumpf.modules.ConstantSignalGenerator(value=0.5,samplingrate=sine.GetSamplingRate(),length=len(sine)).GetSignal() - \
sumpf.modules.AmplifySignal(factor=0.5,input=cos_2).GetOutput()
theoreticl_op_3 = sumpf.modules.AmplifySignal(factor=3.0/4.0,input=sine).GetOutput() - \
sumpf.modules.AmplifySignal(factor=3.0/4.0,input=sine_3).GetOutput()
branch_simple_2 = nlsp.HammersteinModel(
input_signal=sine, nonlin_func=nlsp.function_factory.power_series(2))
branch_simple_3 = nlsp.HammersteinModel(
input_signal=sine, nonlin_func=nlsp.function_factory.power_series(3))
branch_up_2 = nlsp.AliasCompensatingHammersteinModelUpandDown(
input_signal=sine,
nonlin_func=nlsp.function_factory.power_series(2),
max_harm=2)
branch_up_3 = nlsp.AliasCompensatingHammersteinModelUpandDown(
input_signal=sine,
nonlin_func=nlsp.function_factory.power_series(3),
max_harm=3)
branch_lp_2 = nlsp.AliasCompensatingHammersteinModelLowpass(
input_signal=sine,
nonlin_func=nlsp.function_factory.power_series(2),
max_harm=2)
branch_lp_3 = nlsp.AliasCompensatingHammersteinModelLowpass(
input_signal=sine,
nonlin_func=nlsp.function_factory.power_series(3),
max_harm=3)
snr_simple_2 = nlsp.snr(theoreticl_op_2, branch_simple_2.GetOutput())
snr_simple_3 = nlsp.snr(theoreticl_op_3, branch_simple_3.GetOutput())
snr_up_2 = nlsp.snr(theoreticl_op_2, branch_up_2.GetOutput())
snr_up_3 = nlsp.snr(theoreticl_op_3, branch_up_3.GetOutput())
snr_lp_2 = nlsp.snr(theoreticl_op_2, branch_lp_2.GetOutput())
snr_lp_3 = nlsp.snr(theoreticl_op_3, branch_lp_3.GetOutput())
# plot.relabelandplot(sumpf.modules.FourierTransform(branch_simple.GetOutput()).GetSpectrum(),"simpleout",show=False)
plot.relabelandplot(branch_up_2.GetOutput(), "upout", show=False)
# plot.relabelandplot(sumpf.modules.FourierTransform(branch_lp.GetOutput()).GetSpectrum(),"lpout",show=False)
plot.relabelandplot(theoreticl_op_2, "theoryout", show=True)
# plot.relabelandplot(sumpf.modules.FourierTransform(ip_sine).GetSpectrum(),"input",show=True)
# print "simple,2nd degree:%r" %snr_simple_2
# print "simple,3rd degree:%r" %snr_simple_3
print "up,2nd degree:%r" % snr_up_2
print "up,3rd degree:%r" % snr_up_3
print "lp,2nd degree:%r" % snr_lp_2
print "lp,3rd degree:%r" % snr_lp_3
def hardvssoft():
sampling_rate = 48000.0
start_freq = 20.0
stop_freq = 20000.0
length = 2**16
fade_out = 0.00
fade_in = 0.00
sine = 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)
thresholds = [-1.0,1.0]
power = 1.0/3.0
ref_nlsystem_hard_symmetric = sumpf.modules.ClipSignal(thresholds=[-0.7,0.7])
ref_nlsystem_hard_nonsymmetric = sumpf.modules.ClipSignal(thresholds=[-0.6,0.8])
ref_nlsystem_soft = nlsp.NLClipSignal(power=power)
ref_nlsystem_hard_nonsymmetric.SetInput(sine.GetOutput())
ref_nlsystem_hard_symmetric.SetInput(sine.GetOutput())
ref_nlsystem_soft.SetInput(sine.GetOutput())
soft_ir = nlsp.getnl_ir(sine,ref_nlsystem_soft.GetOutput())
hard_symm_ir = nlsp.getnl_ir(sine,ref_nlsystem_hard_symmetric.GetOutput())
hard_nonsymm_ir = nlsp.getnl_ir(sine,ref_nlsystem_hard_nonsymmetric.GetOutput())
# plot.relabelandplot(soft_ir,"soft clipping IR",show=False)
# plot.relabelandplot(hard_nonsymm_ir,"nonsymmetric hard clipping IR",show=False)
# plot.relabelandplot(hard_symm_ir,"symmetric hard clipping IR",show=True)
sine = sumpf.modules.SineWaveGenerator(frequency=1000.0,samplingrate=sampling_rate,length=length)
ref_nlsystem_hard_nonsymmetric.SetInput(sine.GetSignal())
ref_nlsystem_hard_symmetric.SetInput(sine.GetSignal())
ref_nlsystem_soft.SetInput(sine.GetSignal())
# plot.relabelandplot(sumpf.modules.FourierTransform(ref_nlsystem_soft.GetOutput()).GetSpectrum(),"soft clipping output",show=False)
plot.relabelandplot(sumpf.modules.FourierTransform(ref_nlsystem_hard_nonsymmetric.GetOutput()).GetSpectrum(),"nonsymmetric hard clipping output",show=False)
plot.relabelandplot(sumpf.modules.FourierTransform(ref_nlsystem_hard_symmetric.GetOutput()).GetSpectrum(),"symmetric hard clipping output",show=True)
def clippingHGMevaluation(input_generator,
branches,
iden_method,
Plot,
reference=None):
"""
Evaluation of System Identification method by hard clipping system
nonlinear system - virtual clipping systems which hard clips the signal amplitute which are not in the threshold range
plot - the virtual nl system output and the identified nl system output
expectation - utmost similarity between the two outputs
"""
for t in range(8, 11):
t = t / 10.0
thresholds = [-t, t]
input_signal = input_generator.GetOutput()
nl_functions = [
nlsp.function_factory.hardclip(thresholds),
] * branches
filter_spec_tofind = nlsp.log_bpfilter(branches=branches,
input=input_signal)
ref_nlsystem = nlsp.HammersteinGroupModel_up(
input_signal=input_signal,
nonlinear_functions=nl_functions,
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))
# sine = sumpf.modules.SineWaveGenerator(frequency=5000.0,phase=0.0,samplingrate=input_signal.GetSamplingRate(),length=len(input_signal)).GetSignal()
sine = sumpf.modules.SweepGenerator(
samplingrate=input_signal.GetSamplingRate(),
length=len(input_signal)).GetSignal()
ref_nlsystem.SetInput(sine)
iden_nlsystem.SetInput(sine)
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=False)
print "SNR between Reference and Identified output for symmetric hardclipping HGM(thresholds:%r): %r" % (
thresholds,
nlsp.snr(ref_nlsystem.GetOutput(), iden_nlsystem.GetOutput()))
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 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 nonsymmetric_hardclipping_evaluation(input_generator,
branches,
iden_method,
Plot,
reference=None):
"""
Evaluation of System Identification method by hard clipping system
nonlinear system - virtual clipping systems which hard clips the signal amplitute which are not in the threshold range
plot - the virtual nl system output and the identified nl system output
expectation - utmost similarity between the two outputs
"""
t1 = range(8, 11)
t2 = range(8, 11)
for th1, th2 in itertools.product(t1, t2):
th1 = th1 / 10.0
th2 = th2 / 10.0
thresholds = [-th1, th2]
input_signal = input_generator.GetOutput()
ref_nlsystem = sumpf.modules.ClipSignal(thresholds=thresholds)
ref_nlsystem.SetInput(input_signal)
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:
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=False)
print "SNR between Reference and Identified output for non symmetric hardclipping(thresholds:%r): %r" % (
thresholds,
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 wgn_evaluation():
degree = 5
print "wgn evaluation"
for degree in range(3, degree + 1):
wgn = sumpf.modules.NoiseGenerator(
sumpf.modules.NoiseGenerator.GaussianDistribution(
mean=0.0, standard_deviation=1.0),
samplingrate=sampling_rate,
length=length)
prp = sumpf.modules.ChannelDataProperties()
prp.SetSignal(wgn.GetSignal())
filter = sumpf.modules.RectangleFilterGenerator(
resolution=prp.GetResolution(),
length=prp.GetSpectrumLength()).GetSpectrum()
ref = nlsp.HammersteinModel(
input_signal=wgn.GetSignal(),
nonlin_func=nlsp.function_factory.power_series(degree),
filter_impulseresponse=sumpf.modules.InverseFourierTransform(
filter).GetSignal()).GetOutput()
model_simple = nlsp.HammersteinModel(
input_signal=wgn.GetSignal(),
nonlin_func=nlsp.function_factory.power_series(degree))
model_up = nlsp.AliasCompensatingHammersteinModelUpandDown(
input_signal=wgn.GetSignal(),
nonlin_func=nlsp.function_factory.power_series(degree),
max_harm=degree)
model_lp = nlsp.AliasCompensatingHammersteinModelLowpass(
input_signal=wgn.GetSignal(),
nonlin_func=nlsp.function_factory.power_series(degree),
max_harm=degree)
print "degree %r" % degree
print nlsp.snr(model_simple.GetOutput(), ref)
print nlsp.snr(model_up.GetOutput(), ref)
print nlsp.snr(model_lp.GetOutput(), ref)
print
print
if Plot is True:
plot.relabelandplot(sumpf.modules.FourierTransform(
model_up.GetOutput()).GetSpectrum(),
"Upsampling HM",
show=False)
plot.relabelandplot(
sumpf.modules.FourierTransform(ref).GetSpectrum(),
"Upsampling HM Ref")
plot.relabelandplot(sumpf.modules.FourierTransform(
model_lp.GetOutput()).GetSpectrum(),
"Lowpass HM",
show=False)
plot.relabelandplot(
sumpf.modules.FourierTransform(ref).GetSpectrum(),
"Lowpass HM Ref")
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 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 differentdeconcolution():
sampling_rate = 48000.0
start_freq = 100.0
stop_freq = 20000.0
length = 2**18
fade_out = 0.00
fade_in = 0.00
branches = 5
sine = 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)
sine_f = nlsp.NovakSweepGenerator_Sine(sampling_rate=sampling_rate, length=length, start_frequency=start_freq,
stop_frequency=stop_freq, fade_out= 0.02,fade_in=0.02)
source_dir = "C:/Users/diplomand.8/Desktop/nl_recordings/rec_4_db/"
load_sine = sumpf.modules.SignalFile(filename=os.path.join(source_dir,"sine.npz"), format=sumpf.modules.SignalFile.WAV_FLOAT)
load_sine_f = sumpf.modules.SignalFile(filename=os.path.join(source_dir,"sine_f.npz"), format=sumpf.modules.SignalFile.WAV_FLOAT)
output_sine = sumpf.modules.SplitSignal(data=load_sine.GetSignal(),channels=[1]).GetOutput()
output_sine_f = sumpf.modules.SplitSignal(data=load_sine_f.GetSignal(),channels=[1]).GetOutput()
ir_reverse = nlsp.get_nl_impulse_response(sine,output_sine)
ir_specinv = nlsp.get_impulse_response(sine.GetOutput(),output_sine,start_freq,stop_freq)
ir_specinv_fade = nlsp.get_impulse_response(sine_f.GetOutput(),output_sine_f,start_freq,stop_freq)
plot.relabelandplot(ir_specinv,show=True,label="IR_SpectralInversion")
plot.relabelandplot(ir_specinv_fade,show=True,label="IR_SpectralInversion_fade")
plot.relabelandplot(ir_reverse,show=True,label="IR_Reverse")
def reliability_evaluation_puretone():
length = 2**15
for max_harm in range(3, 6):
frequencies = [100, 500, 1000, 2000, 4000]
puretones = nlsp.generate_puretones(frequencies, sampling_rate, length)
ip_signal = puretones
nl_degree = max_harm
model_simple = nlsp.HammersteinModel(
input_signal=puretones,
nonlin_func=nlsp.function_factory.power_series(nl_degree))
model_up = nlsp.AliasCompensatingHammersteinModelUpandDown(
input_signal=ip_signal,
nonlin_func=nlsp.function_factory.power_series(nl_degree),
max_harm=max_harm)
model_lp = nlsp.AliasCompensatingHammersteinModelLowpass(
input_signal=ip_signal,
nonlin_func=nlsp.function_factory.power_series(nl_degree),
max_harm=max_harm)
# plot.relabelandplot(sumpf.modules.FourierTransform(model_simple.GetOutput()).GetSpectrum(),"Uncompensated",show=False)
# plot.relabelandplot(sumpf.modules.FourierTransform(model_up.GetOutput()).GetSpectrum(),"Upsampling",show=False)
# plot.relabelandplot(sumpf.modules.FourierTransform(model_lp.GetOutput()).GetSpectrum(),"Lowpass filtering",show=True)
plot.relabelandplot(model_simple.GetOutput(),
"Uncompensated",
show=False)
plot.relabelandplot(model_up.GetOutput(), "upsampling", show=False)
plot.relabelandplot(model_lp.GetOutput(), "lowpass", show=True)
print "maxharmonics: %r" % max_harm
print "snr between simple HGM and upsampling HGM: %r" % nlsp.snr(
model_simple.GetOutput(), model_up.GetOutput())
print "snr between simple HGM and lowpass HGM: %r" % nlsp.snr(
model_simple.GetOutput(), model_lp.GetOutput())
print
def regularizedspectraldivision(input_signal,response):
"""
regularized spectral division vs normal spectral division
"""
input_spec = sumpf.modules.FourierTransform(input_signal).GetSpectrum()
response_spec = sumpf.modules.FourierTransform(response).GetSpectrum()
normal_tf = sumpf.modules.DivideSpectrums(spectrum1=response_spec, spectrum2=input_spec).GetOutput()
reg_inv = sumpf.modules.RegularizedSpectrumInversion(spectrum=input_spec,start_frequency=20.0,stop_frequency=20000.0).GetOutput()
reg_specdivision = sumpf.modules.MultiplySpectrums(spectrum1=reg_inv, spectrum2=response_spec)
reg_tf = reg_specdivision.GetOutput()
plot.relabelandplot(input_spec,"input spectrum",show=False)
plot.relabelandplot(response_spec,"output spectrum",show=False)
plot.relabelandplot(normal_tf,"transfer function without regularization",show=False)
plot.relabelandplot(reg_tf,"regularized transfer function",show=True)
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 harmonics_evaluation():
degree = 5
length = 2**18
input_signal = nlsp.NovakSweepGenerator_Sine(
sampling_rate=sampling_rate,
length=length,
start_frequency=sweep_start_freq,
stop_frequency=sweep_stop_freq)
input_sweep_signal = input_signal.GetOutput()
for i in range(degree, degree + 1):
prp = sumpf.modules.ChannelDataProperties()
prp.SetSignal(input_sweep_signal)
filter = sumpf.modules.FilterGenerator(
filterfunction=sumpf.modules.FilterGenerator.BUTTERWORTH(
order=100),
frequency=24000.0,
transform=False,
resolution=prp.GetResolution(),
length=prp.GetSpectrumLength()).GetSpectrum()
filter_ir = sumpf.modules.InverseFourierTransform(filter).GetSignal()
branch_simple = nlsp.HammersteinModel(
input_signal=input_sweep_signal,
nonlin_func=nlsp.function_factory.power_series(i),
filter_impulseresponse=filter_ir)
branch_up = nlsp.AliasCompensatingHammersteinModelUpandDown(
input_signal=input_sweep_signal,
nonlin_func=nlsp.function_factory.power_series(i),
max_harm=i,
filter_impulseresponse=filter_ir)
branch_lp = nlsp.AliasCompensatingHammersteinModelLowpass(
input_signal=input_sweep_signal,
nonlin_func=nlsp.function_factory.power_series(i),
max_harm=i,
filter_impulseresponse=filter_ir)
harm_simple = nlsp.get_nl_impulse_response(input_signal,
branch_simple.GetOutput())
harm_up = nlsp.get_nl_impulse_response(input_signal,
branch_up.GetOutput())
harm_lowpass = nlsp.get_nl_impulse_response(input_signal,
branch_lp.GetOutput())
plot.relabelandplot(harm_simple, "simple HM", show=True)
plot.relabelandplot(harm_up, "upsampling HM", show=True)
plot.relabelandplot(harm_lowpass, "lowpass HM", show=True)
print nlsp.harmonicsvsall_energyratio_nl(input_signal,
branch_simple.GetOutput(), i)
print nlsp.harmonicsvsall_energyratio_nl(input_signal,
branch_up.GetOutput(), i)
print nlsp.harmonicsvsall_energyratio_nl(input_signal,
branch_lp.GetOutput(), i)
print
print
def linearity_evaluation():
print "linearity evaluation"
for i in range(3, degree + 1):
max_harm = i
nl_degree = i
sweep_start_freq = 20.0
sweep_stop_freq = 4000.0
ip_sweep_signal = sumpf.modules.SweepGenerator(
samplingrate=sampling_rate,
length=length,
start_frequency=sweep_start_freq,
stop_frequency=sweep_stop_freq).GetSignal()
model_simple = nlsp.HammersteinModel(
input_signal=ip_sweep_signal,
nonlin_func=nlsp.function_factory.power_series(nl_degree))
model_up = nlsp.AliasCompensatingHammersteinModelUpandDown(
input_signal=ip_sweep_signal,
nonlin_func=nlsp.function_factory.power_series(nl_degree),
max_harm=max_harm)
model_lp = nlsp.AliasCompensatingHammersteinModelLowpass(
input_signal=ip_sweep_signal,
nonlin_func=nlsp.function_factory.power_series(nl_degree),
max_harm=max_harm)
simple_ref = model_simple.GetOutput()
up_ip = model_up.GetOutput()
lp_ip = model_lp.GetOutput()
print "degree %r" % i
print nlsp.snr(simple_ref, simple_ref)
print nlsp.snr(up_ip, simple_ref)
print nlsp.snr(lp_ip, simple_ref)
print
print
if Plot is True:
plot.log()
plot.relabelandplot(sumpf.modules.FourierTransform(
model_simple.GetOutput()).GetSpectrum(),
"Reference",
show=False)
plot.relabelandplot(sumpf.modules.FourierTransform(
model_up.GetOutput()).GetSpectrum(),
"Upsampling HM",
show=False)
plot.relabelandplot(sumpf.modules.FourierTransform(
model_lp.GetOutput()).GetSpectrum(),
"Lowpass HM",
show=True)
def reliability_evaluation_sweep():
length = 2**15
for max_harm in range(1, 6):
sweep = nlsp.NovakSweepGenerator_Sine(sampling_rate=sampling_rate,
length=length,
start_frequency=20.0,
stop_frequency=2000.0)
ip_signal = sweep.GetOutput()
nl_degree = max_harm
model_simple = nlsp.HammersteinModel(
input_signal=ip_signal,
nonlin_func=nlsp.function_factory.power_series(nl_degree))
model_up = nlsp.AliasCompensatingHammersteinModelUpandDown(
input_signal=ip_signal,
nonlin_func=nlsp.function_factory.power_series(nl_degree),
max_harm=max_harm)
model_lp = nlsp.AliasCompensatingHammersteinModelLowpass(
input_signal=ip_signal,
nonlin_func=nlsp.function_factory.power_series(nl_degree),
max_harm=max_harm)
# plot.relabelandplot(sumpf.modules.FourierTransform(model_simple.GetOutput()).GetSpectrum(),"simple",show=False)
# plot.relabelandplot(sumpf.modules.FourierTransform(model_up.GetOutput()).GetSpectrum(),"upsampling",show=False)
# plot.relabelandplot(sumpf.modules.FourierTransform(model_lp.GetOutput()).GetSpectrum(),"lowpass",show=True)
plot.relabelandplot(model_simple.GetOutput(),
"Uncompensated",
show=False)
plot.relabelandplot(model_up.GetOutput(), "Upsampling", show=False)
plot.relabelandplot(model_lp.GetOutput(),
"Lowpass filtering",
show=True)
print "maxharmonics: %r" % max_harm
print "snr between simple HGM and upsampling HGM: %r" % nlsp.snr(
model_simple.GetOutput(), model_up.GetOutput())
print "snr between simple HGM and lowpass HGM: %r" % nlsp.snr(
model_simple.GetOutput(), model_lp.GetOutput())
print "snr between simple HGM and upsampling HGM magnitude: %r" % nlsp.snr_magnitude(
model_simple.GetOutput(), model_up.GetOutput())
print "snr between simple HGM and lowpass HGM magnitude: %r" % nlsp.snr_magnitude(
model_simple.GetOutput(), model_lp.GetOutput())
print
def loudspeaker_evaluation_all(branches=3, Plot=True):
branches = branches
sampling_rate = 48000.0
length = 2**18
start_freq = 100.0
stop_freq = 20000.0
fade_out = 0.02
fade_in = 0.02
filter_taps = 2**10
iterations = 5
source_dir = "C:/Users/diplomand.8/Desktop/nl_recordings/rec_4_db/"
# 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=os.path.join(source_dir, "Noise18.npz"),
format=sumpf.modules.SignalFile.WAV_FLOAT)
load_sine = sumpf.modules.SignalFile(
filename=os.path.join(source_dir, "sine_f.npz"),
format=sumpf.modules.SignalFile.WAV_FLOAT)
load_cosine = sumpf.modules.SignalFile(
filename=os.path.join(source_dir, "cos_f.npz"),
format=sumpf.modules.SignalFile.WAV_FLOAT)
load_sample = sumpf.modules.SignalFile(
filename=os.path.join(source_dir, "Music1.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()
output_sample = nlsp.change_length_signal(output_sample, 2**18)
input_sample = nlsp.change_length_signal(input_sample, 2**18)
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()
# linear identification
kernel_linear, nlfunc = nlsp.linear_identification(sine_g, output_sine,
branches)
iden_nlsystem_linear = nlsp.HammersteinGroupModel_up(
filter_irs=kernel_linear, nonlinear_functions=nlfunc)
# linear identification
kernel_linear_hgm, nlfunc_hgm = nlsp.linear_identification_powerhgm(
sine_g, output_sine, branches)
iden_nlsystem_linear_hgm = nlsp.HammersteinGroupModel_up(
filter_irs=kernel_linear_hgm, nonlinear_functions=nlfunc_hgm)
# only sine based system identification
# found_filter_spec_sine, nl_function_sine = nlsp.systemidentification("LS",nlsp.nonlinearconvolution_powerseries_temporalreversal,
# branches,sine_g,output_sine)
found_filter_spec_sine, nl_function_sine = nlsp.nonlinearconvolution_powerseries_temporalreversal(
sine_g, output_sine, branches)
iden_nlsystem_sine = nlsp.HammersteinGroupModel_up(
max_harmonics=range(1, branches + 1),
nonlinear_functions=nl_function_sine,
filter_irs=found_filter_spec_sine)
# only cosine based system identification
# found_filter_spec_cos, nl_function_cos = nlsp.systemidentification("LS",nlsp.nonlinearconvolution_chebyshev_temporalreversal,
# branches,cos_g,output_cos)
found_filter_spec_cos, nl_function_cos = nlsp.nonlinearconvolution_chebyshev_temporalreversal(
cos_g, output_cos, branches)
iden_nlsystem_cos = nlsp.HammersteinGroupModel_up(
max_harmonics=range(1, branches + 1),
nonlinear_functions=nl_function_cos,
filter_irs=found_filter_spec_cos)
# only noise based system identification
# found_filter_spec_adapt, nl_function_adapt = nlsp.adaptive_identification_legendre(input_generator=input_noise,outputs=output_noise,iterations=iterations,branches=branches,
# step_size=0.1,filtertaps=filter_taps,algorithm=nlsp.multichannel_nlms,Plot=False)
# iden_nlsystem_adapt = nlsp.HammersteinGroupModel_up(max_harmonics=range(1,branches+1),nonlinear_functions=nl_function_adapt,
# filter_irs=found_filter_spec_adapt)
# 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_legendre(input_generator=input_noise,outputs=output_noise,iterations=iterations,branches=branches,
# step_size=0.1,filtertaps=filter_taps,algorithm=nlsp.multichannel_nlms,Plot=False,init_coeffs=found_filter_spec_sine_reducedlength)
# iden_nlsystem_sineadapt = nlsp.HammersteinGroupModel_up(max_harmonics=range(1,branches+1),nonlinear_functions=nl_function_sineadapt,
# filter_irs=found_filter_spec_sineadapt)
# 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_powerseries(input_generator=input_noise,outputs=output_noise,iterations=iterations,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_cosadapt = nlsp.HammersteinGroupModel_up(max_harmonics=range(1,branches+1),nonlinear_functions=nl_function_cosadapt,
# filter_irs=found_filter_spec_cosadapt)
# set excitation as input
iden_nlsystem_linear.SetInput(sine_g.GetOutput())
iden_nlsystem_linear_hgm.SetInput(sine_g.GetOutput())
iden_nlsystem_sine.SetInput(sine_g.GetOutput())
iden_nlsystem_cos.SetInput(cos_g.GetOutput())
# iden_nlsystem_adapt.SetInput(input_noise)
# iden_nlsystem_sineadapt.SetInput(input_noise)
# iden_nlsystem_cosadapt.SetInput(input_noise)
plot.relabelandplot(
sumpf.modules.FourierTransform(output_sine).GetSpectrum(),
"Reference system",
show=False)
plot.relabelandplot(sumpf.modules.FourierTransform(
iden_nlsystem_sine.GetOutput()).GetSpectrum(),
"Sweep based system identification",
show=False)
plot.relabelandplot(sumpf.modules.FourierTransform(
iden_nlsystem_linear.GetOutput()).GetSpectrum(),
"Linear identified system",
show=True)
if Plot is True:
# plot.relabelandplot(sumpf.modules.FourierTransform(iden_nlsystem_sine.GetOutput()).GetSpectrum(),"Identified power",show=False)
plot.relabelandplot(
sumpf.modules.FourierTransform(output_sine).GetSpectrum(),
"Reference system",
show=False)
plot.relabelandplot(sumpf.modules.FourierTransform(
iden_nlsystem_linear.GetOutput()).GetSpectrum(),
"Linear identified system",
show=False)
plot.relabelandplot(sumpf.modules.FourierTransform(
iden_nlsystem_sineadapt.GetOutput()).GetSpectrum(),
"sweep-adaptive output",
show=True)
# plot.relabelandplot(sumpf.modules.FourierTransform(iden_nlsystem_cos.GetOutput()).GetSpectrum(),"Identified cheby",show=False)
# plot.relabelandplot(sumpf.modules.FourierTransform(output_cos).GetSpectrum(),"Reference cheby",show=True)
# plot.relabelandplot(sumpf.modules.FourierTransform(iden_nlsystem_adapt.GetOutput()).GetSpectrum(),"Identified Adapt noise",show=False)
# plot.relabelandplot(sumpf.modules.FourierTransform(iden_nlsystem_sineadapt.GetOutput()).GetSpectrum(),"Identified power Adapt noise",show=False)
# plot.relabelandplot(sumpf.modules.FourierTransform(iden_nlsystem_cosadapt.GetOutput()).GetSpectrum(),"Identified chebyshev Adapt noise",show=False)
# plot.relabelandplot(sumpf.modules.FourierTransform(output_noise).GetSpectrum(),"Reference Adapt noise",show=True)
print "SNR between Reference and Identified output linear: %r" % nlsp.snr(
output_sine, iden_nlsystem_linear.GetOutput())
print "SNR between Reference and Identified output linear hgm: %r" % nlsp.snr(
output_sine, iden_nlsystem_linear_hgm.GetOutput())
print "SNR between Reference and Identified output Powerseries NL convolution: %r" % nlsp.snr(
output_sine, iden_nlsystem_sine.GetOutput())
print "SNR between Reference and Identified output Chebyshev NL convolution: %r" % nlsp.snr(
output_cos, iden_nlsystem_cos.GetOutput())
print "SNR between Reference and Identified output Adaptive: %r" % nlsp.snr(
output_noise, iden_nlsystem_adapt.GetOutput())
print "SNR between Reference and Identified output Powerseries Adaptive: %r" % nlsp.snr(
output_noise, iden_nlsystem_sineadapt.GetOutput())
# print "SNR between Reference and Identified output Chebyshev Adaptive: %r" %nlsp.snr(output_noise, iden_nlsystem_cosadapt.GetOutput())
# set sample as input
iden_nlsystem_linear.SetInput(input_sample)
iden_nlsystem_linear_hgm.SetInput(input_sample)
iden_nlsystem_sine.SetInput(input_sample)
iden_nlsystem_cos.SetInput(input_sample)
iden_nlsystem_adapt.SetInput(input_sample)
iden_nlsystem_sineadapt.SetInput(input_sample)
# iden_nlsystem_cosadapt.SetInput(input_sample)
# if Plot is True:
# plot.relabelandplot(sumpf.modules.FourierTransform(iden_nlsystem_sine.GetOutput()).GetSpectrum(),"Identified power",show=False)
# plot.relabelandplot(sumpf.modules.FourierTransform(iden_nlsystem_cos.GetOutput()).GetSpectrum(),"Identified cheby",show=False)
# plot.relabelandplot(sumpf.modules.FourierTransform(iden_nlsystem_adapt.GetOutput()).GetSpectrum(),"Identified Adapt noise",show=False)
# plot.relabelandplot(sumpf.modules.FourierTransform(iden_nlsystem_sineadapt.GetOutput()).GetSpectrum(),"Identified power Adapt noise",show=False)
# plot.relabelandplot(sumpf.modules.FourierTransform(iden_nlsystem_cosadapt.GetOutput()).GetSpectrum(),"Identified chebyshev Adapt noise",show=False)
# plot.relabelandplot(sumpf.modules.FourierTransform(output_sample).GetSpectrum(),"Reference Adapt noise",show=True)
print "SNR between Reference and Identified output linear: %r" % nlsp.snr(
output_sample, iden_nlsystem_linear.GetOutput())
print "SNR between Reference and Identified output linear hgm: %r" % nlsp.snr(
output_sample, iden_nlsystem_linear_hgm.GetOutput())
print "SNR between Reference and Identified output Powerseries NL convolution: %r" % nlsp.snr(
output_sample, iden_nlsystem_sine.GetOutput())
print "SNR between Reference and Identified output Chebyshev NL convolution: %r" % nlsp.snr(
output_sample, iden_nlsystem_cos.GetOutput())
print "SNR between Reference and Identified output Adaptive: %r" % nlsp.snr(
output_sample, iden_nlsystem_adapt.GetOutput())
print "SNR between Reference and Identified output Powerseries Adaptive: %r" % nlsp.snr(
output_sample, iden_nlsystem_sineadapt.GetOutput())
def adaptive_polynomial_evaluation_realworld():
# real world reference system, load input and output noise
load_wgn_normal = sumpf.modules.SignalFile(
filename=os.path.join(source_dir, "wgn_normal_16.npz"),
format=sumpf.modules.SignalFile.WAV_FLOAT)
load_wgn_uniform = sumpf.modules.SignalFile(
filename=os.path.join(source_dir, "wgn_uniform_16.npz"),
format=sumpf.modules.SignalFile.WAV_FLOAT)
load_wgn_gamma = sumpf.modules.SignalFile(
filename=os.path.join(source_dir, "wgn_gamma_16.npz"),
format=sumpf.modules.SignalFile.WAV_FLOAT)
load_wgn_pink = sumpf.modules.SignalFile(
filename=os.path.join(source_dir, "wgn_pink_16.npz"),
format=sumpf.modules.SignalFile.WAV_FLOAT)
input_wgn_normal = sumpf.modules.SplitSignal(
data=load_wgn_normal.GetSignal(), channels=[0]).GetOutput()
output_wgn_normal = sumpf.modules.SplitSignal(
data=load_wgn_normal.GetSignal(), channels=[1]).GetOutput()
input_wgn_uniform = sumpf.modules.SplitSignal(
data=load_wgn_uniform.GetSignal(), channels=[0]).GetOutput()
output_wgn_uniform = sumpf.modules.SplitSignal(
data=load_wgn_uniform.GetSignal(), channels=[1]).GetOutput()
input_wgn_gamma = sumpf.modules.SplitSignal(
data=load_wgn_gamma.GetSignal(), channels=[0]).GetOutput()
output_wgn_gamma = sumpf.modules.SplitSignal(
data=load_wgn_gamma.GetSignal(), channels=[1]).GetOutput()
input_wgn_pink = sumpf.modules.SplitSignal(data=load_wgn_pink.GetSignal(),
channels=[0]).GetOutput()
output_wgn_pink = sumpf.modules.SplitSignal(data=load_wgn_pink.GetSignal(),
channels=[1]).GetOutput()
for nlfunc in nl_functions:
print nlfunc
found_filter_spec_normal, nl_func_normal = nlsp.adaptive_identification(
input_wgn_normal,
output_wgn_normal,
branches,
nonlinear_func=nlfunc)
found_filter_spec_uniform, nl_func_uniform = nlsp.adaptive_identification(
input_wgn_uniform,
output_wgn_uniform,
branches,
nonlinear_func=nlfunc)
found_filter_spec_gamma, nl_func_gamma = nlsp.adaptive_identification(
input_wgn_gamma, output_wgn_gamma, branches, nonlinear_func=nlfunc)
iden_nlsystem_normal = nlsp.HammersteinGroupModel_up(
input_signal=input_wgn_normal,
nonlinear_functions=nl_func_normal,
filter_irs=found_filter_spec_normal,
max_harmonics=range(1, branches + 1))
iden_nlsystem_uniform = nlsp.HammersteinGroupModel_up(
input_signal=input_wgn_uniform,
nonlinear_functions=nl_func_uniform,
filter_irs=found_filter_spec_uniform,
max_harmonics=range(1, branches + 1))
iden_nlsystem_gamma = nlsp.HammersteinGroupModel_up(
input_signal=input_wgn_gamma,
nonlinear_functions=nl_func_gamma,
filter_irs=found_filter_spec_gamma,
max_harmonics=range(1, branches + 1))
iden_nlsystem_normal.SetInput(input_wgn_pink)
iden_nlsystem_gamma.SetInput(input_wgn_pink)
iden_nlsystem_uniform.SetInput(input_wgn_pink)
if Plot is True:
plot.relabelandplot(
sumpf.modules.FourierTransform(output_wgn_pink).GetSpectrum(),
"Reference Output",
show=False)
plot.relabelandplot(sumpf.modules.FourierTransform(
iden_nlsystem_normal.GetOutput()).GetSpectrum(),
"Identified Output",
show=True)
print "SNR between Reference and Identified output without overlapping filters Normal: %r" % nlsp.snr(
output_wgn_pink, iden_nlsystem_normal.GetOutput())
if Plot is True:
plot.relabelandplot(
sumpf.modules.FourierTransform(output_wgn_pink).GetSpectrum(),
"Reference Output",
show=False)
plot.relabelandplot(sumpf.modules.FourierTransform(
iden_nlsystem_uniform.GetOutput()).GetSpectrum(),
"Identified Output",
show=True)
print "SNR between Reference and Identified output without overlapping filters Uniform: %r" % nlsp.snr(
output_wgn_pink, iden_nlsystem_uniform.GetOutput())
if Plot is True:
plot.relabelandplot(
sumpf.modules.FourierTransform(output_wgn_pink).GetSpectrum(),
"Reference Output",
show=False)
plot.relabelandplot(sumpf.modules.FourierTransform(
iden_nlsystem_gamma.GetOutput()).GetSpectrum(),
"Identified Output",
show=True)
print "SNR between Reference and Identified output without overlapping filters Gamma: %r" % nlsp.snr(
output_wgn_pink, iden_nlsystem_gamma.GetOutput())
import sumpf
import nlsp
import nlsp.common.plots as plot
start_frequency = 20.0
stop_frequency = 20000.0
length = 2**15
branches = 3
sampling_rate = 48000
novak_sweep = nlsp.NovakSweepGenerator_Sine(start_frequency=start_frequency, stop_frequency=stop_frequency,
sampling_rate=sampling_rate, length=length)
farina_sweep = nlsp.FarinaSweepGenerator_Sine(start_frequency=start_frequency, stop_frequency=stop_frequency,
sampling_rate=sampling_rate, length=length)
input_signal_novak = novak_sweep.GetOutput()
input_signal_farina = farina_sweep.GetOutput()
filter_spec_tofind_novak = nlsp.log_bpfilter(branches=branches,input=input_signal_novak)
filter_spec_tofind_farina = nlsp.log_bpfilter(branches=branches,input=input_signal_farina)
ref_nlsystem_novak = nlsp.HammersteinGroupModel_up(nonlinear_functions=nlsp.nl_branches(nlsp.function_factory.power_series,branches),
filter_irs=filter_spec_tofind_novak,
max_harmonics=range(1,branches+1))
ref_nlsystem_farina = nlsp.HammersteinGroupModel_up(nonlinear_functions=nlsp.nl_branches(nlsp.function_factory.power_series,branches),
filter_irs=filter_spec_tofind_farina,
max_harmonics=range(1,branches+1))
ref_nlsystem_novak.SetInput(input_signal_novak)
ref_nlsystem_farina.SetInput(input_signal_farina)
ir_novak = nlsp.getnl_ir(novak_sweep,ref_nlsystem_novak.GetOutput(),branches)
ir_farina = nlsp.getnl_ir(farina_sweep,ref_nlsystem_farina.GetOutput(),branches)
plot.relabelandplot(ir_novak,"IR with synchronization",show=False)
plot.relabelandplot(ir_farina,"IR without synchronization",show=True)
def linearmodel_evaluation(input_generator,
branches,
nlfunction,
iden_method,
Plot,
reference=None):
"""
Evaluation of System Identification method by linear amplification
nonlinear system - no nonlinearity, linear amplifier as linear system
inputsignal - signal signal
plot - the virtual linear system output and the identified linear system output
expectation - utmost similarity between the two outputs
"""
input_signal = input_generator.GetOutput()
prp = sumpf.modules.ChannelDataProperties()
prp.SetSignal(input_signal)
filter_ir = sumpf.modules.FilterGenerator(
filterfunction=sumpf.modules.FilterGenerator.BUTTERWORTH(order=10),
frequency=10000.0,
transform=False,
resolution=prp.GetResolution(),
length=prp.GetSpectrumLength()).GetSpectrum()
ref_nlsystem = nlsp.AliasingCompensatedHM_upsampling(
filter_impulseresponse=sumpf.modules.InverseFourierTransform(
filter_ir).GetSignal())
ref_nlsystem.SetInput(input_signal)
# nonlinear system identification
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))
# linear system identification
sweep = nlsp.NovakSweepGenerator_Sine(
length=len(input_signal), sampling_rate=input_signal.GetSamplingRate())
ref_nlsystem.SetInput(sweep.GetOutput())
kernel_linear = nlsp.linear_identification_temporalreversal(
sweep, ref_nlsystem.GetOutput())
iden_linsystem = nlsp.AliasCompensatingHammersteinModelUpandDown(
filter_impulseresponse=kernel_linear)
if reference is not None:
reference = nlsp.change_length_signal(reference,
length=len(input_signal))
ref_nlsystem.SetInput(reference)
iden_linsystem.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=False)
plot.relabelandplot(sumpf.modules.FourierTransform(
iden_linsystem.GetOutput()).GetSpectrum(),
"Identified linear System",
show=True)
print "SNR between Reference and Identified output for linear systems: %r" % nlsp.snr(
ref_nlsystem.GetOutput(), iden_nlsystem.GetOutput())
print "SNR between Reference and Identified output for linear systems(linear identification): %r" % nlsp.snr(
ref_nlsystem.GetOutput(), iden_linsystem.GetOutput())
def loudspeaker_model_sweep(Plot=True):
sampling_rate = 48000.0
start_freq = 100.0
stop_freq = 20000.0
length = 2**18
fade_out = 0.00
fade_in = 0.00
branches = 3
sine = 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)
op_sine = sumpf.modules.SignalFile(
filename="C:/Users/diplomand.8/Desktop/nl_recordings/rec_4_ls/sine.npz",
format=sumpf.modules.SignalFile.WAV_FLOAT)
op_sine = sumpf.modules.SplitSignal(data=op_sine.GetSignal(),
channels=[1]).GetOutput()
found_filter_spec, nl_functions = nlsp.nonlinearconvolution_chebyshev_adaptive(
sine, op_sine, branches)
iden_nlsystem_sine = nlsp.HammersteinGroupModel_up(
input_signal=sine.GetOutput(),
nonlinear_functions=nl_functions,
filter_irs=found_filter_spec,
max_harmonics=range(1, branches + 1))
linear_op = nlsp.linear_identification_temporalreversal(
sine, op_sine, sine.GetOutput())
if Plot is True:
plot.relabelandplot(
sumpf.modules.FourierTransform(op_sine).GetSpectrum(),
"Reference System",
show=False,
line='b-')
plot.relabelandplot(sumpf.modules.FourierTransform(
iden_nlsystem_sine.GetOutput()).GetSpectrum(),
"NL Identified System",
show=False,
line='r-')
plot.relabelandplot(
sumpf.modules.FourierTransform(linear_op).GetSpectrum(),
"Linear Identified System",
show=True,
line='g-')
print "SNR between Reference and Identified output, nonlinear: %r" % nlsp.snr(
op_sine, iden_nlsystem_sine.GetOutput())
print "SNR between Reference and Identified output, linear: %r" % nlsp.snr(
op_sine, linear_op)
load_sample = sumpf.modules.SignalFile(
filename=
"C:/Users/diplomand.8/Desktop/nl_recordings/rec_4_ls/Speech1.npz",
format=sumpf.modules.SignalFile.WAV_FLOAT)
load_sample = nlsp.append_zeros(load_sample.GetSignal())
ref_sample = sumpf.modules.SplitSignal(data=load_sample,
channels=[1]).GetOutput()
ip_sample = sumpf.modules.SplitSignal(data=load_sample,
channels=[0]).GetOutput()
iden_nlsystem_sine.SetInput(ip_sample)
linear_op = nlsp.linear_identification_temporalreversal(
sine, op_sine, ip_sample)
# save the output to the directory
iden = sumpf.modules.SignalFile(
filename=
"C:/Users/diplomand.8/Desktop/nl_recordings/rec_4_ls/sim/identified",
signal=iden_nlsystem_sine.GetOutput(),
format=sumpf.modules.SignalFile.WAV_FLOAT)
ref = sumpf.modules.SignalFile(
filename=
"C:/Users/diplomand.8/Desktop/nl_recordings/rec_4_ls/sim/reference",
signal=ref_sample,
format=sumpf.modules.SignalFile.WAV_FLOAT)
inp = sumpf.modules.SignalFile(
filename=
"C:/Users/diplomand.8/Desktop/nl_recordings/rec_4_ls/sim/input",
signal=ip_sample,
format=sumpf.modules.SignalFile.WAV_FLOAT)
linear = sumpf.modules.SignalFile(
filename=
"C:/Users/diplomand.8/Desktop/nl_recordings/rec_4_ls/sim/linear",
signal=linear_op,
format=sumpf.modules.SignalFile.WAV_FLOAT)
print "Distortion box, SNR between Reference and Identified output Sample,nl: %r" % nlsp.snr(
ref_sample, iden_nlsystem_sine.GetOutput())
print "Distortion box, SNR between Reference and Identified output Sample,l: %r" % nlsp.snr(
ref_sample, linear_op)
def linearmodel_evaluation(input_generator,
branches,
nlfunction,
Plot,
reference=None):
input_signal = input_generator.GetOutput()
prp = sumpf.modules.ChannelDataProperties()
prp.SetSignal(input_signal)
filter_ir = sumpf.modules.FilterGenerator(
filterfunction=sumpf.modules.FilterGenerator.BUTTERWORTH(order=10),
frequency=10000.0,
transform=False,
resolution=prp.GetResolution(),
length=prp.GetSpectrumLength()).GetSpectrum()
ref_nlsystem = nlsp.AliasCompensatingHammersteinModelUpandDown(
filter_impulseresponse=sumpf.modules.InverseFourierTransform(
filter_ir).GetSignal())
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))
# linear system identification
sweep = nlsp.NovakSweepGenerator_Sine(
length=len(input_signal), sampling_rate=input_signal.GetSamplingRate())
ref_nlsystem.SetInput(sweep.GetOutput())
kernel_linear = nlsp.linear_identification_temporalreversal(
sweep, ref_nlsystem.GetOutput())
iden_linsystem = nlsp.AliasCompensatingHammersteinModelUpandDown(
filter_impulseresponse=kernel_linear)
if reference is not None:
reference = nlsp.change_length_signal(reference,
length=len(input_signal))
ref_nlsystem.SetInput(reference)
iden_linsystem.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=False)
plot.relabelandplot(sumpf.modules.FourierTransform(
iden_linsystem.GetOutput()).GetSpectrum(),
"Identified linear System",
show=True)
print "SNR between Reference and Identified output for linear systems: %r" % nlsp.snr(
ref_nlsystem.GetOutput(), iden_nlsystem.GetOutput())
print "SNR between Reference and Identified output for linear systems(linear identification): %r" % nlsp.snr(
ref_nlsystem.GetOutput(), iden_linsystem.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 loudspeaker_model_sweepadaptive():
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)
# 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.relabelandplot(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.plot_sdrvsfreq(output_noise,
iden_nlsystem.GetOutput(),
label="noise",
show=False)
plot.relabelandplot(
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_ls/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/sweepadaptive/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/sweepadaptive/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/sweepadaptive/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 hgmwithfilter_evaluation(input_generator,
branches,
nlfuntion,
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
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.create_bpfilter([2000,8000,30000],input_signal)
filter_spec_tofind = nlsp.log_bpfilter(branches=branches,
input=input_signal)
# filter_spec_tofind = [i for i in reversed(filter_spec_tofind)]
length_kernel = len(filter_spec_tofind[0])
# 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))
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))
# 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(ref_nlsystem.GetOutput(),
"Reference Output",
show=False)
plot.relabelandplot(iden_nlsystem.GetOutput(),
"Identified Output",
show=True)
# nlsp.plot_array([sumpf.modules.FourierTransform(s).GetSpectrum() for s in filter_spec_tofind],label_array=["reference%d" %i for i in range(len(filter_spec_tofind))],Show=False)
# nlsp.plot_array([sumpf.modules.FourierTransform(s).GetSpectrum() for s in found_filter_spec],label_array=["identified%d" %i for i in range(len(found_filter_spec))],Show=True)
print "SNR between Reference and Identified output without overlapping filters: %r" % nlsp.snr(
ref_nlsystem.GetOutput(), iden_nlsystem.GetOutput())
sumpf.modules.SignalFile(
filename=
"C:/Users/diplomand.8/Desktop/linearHGM_explannation/cheby/noise/input",
signal=reference,
format=sumpf.modules.SignalFile.WAV_FLOAT)
sumpf.modules.SignalFile(
filename=
"C:/Users/diplomand.8/Desktop/linearHGM_explannation/cheby/noise/%s" %
iden_method.__name__,
signal=iden_nlsystem.GetOutput(),
format=sumpf.modules.SignalFile.WAV_FLOAT)
sumpf.modules.SignalFile(
filename=
"C:/Users/diplomand.8/Desktop/linearHGM_explannation/cheby/noise/reference",
signal=ref_nlsystem.GetOutput(),
format=sumpf.modules.SignalFile.WAV_FLOAT)
