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)