def test_003_t(self): ''' Measure performance. :return: ''' # Overwrite variables self.n_samples = 1024 * 1000 # Create signal d = np.random.randint( 2, size=self.n_samples) * 2 - 1 # Random bipolar (-1,1) sequence # Channel model W = 2.9 h = np.zeros(4) h[1:4] = 0.5 * (1 + np.cos(2 * np.pi / W * np.linspace(-1, 1, 3))) u = np.convolve(d, h, mode='valid') # Distorted signal u += np.random.normal(0, np.sqrt(0.001), u.size) # Received signal d_source = blocks.vector_source_c(d.tolist()) u_source = blocks.vector_source_c(u.tolist()) lms_filter_cc = adapt.lms_filter_cc(True, self.n_taps, self.mu, self.skip, self.decimation, self.adapt, self.reset) y_sink = blocks.vector_sink_c() e_sink = blocks.vector_sink_c() self.tb.connect(d_source, (lms_filter_cc, 0)) self.tb.connect(u_source, (lms_filter_cc, 1)) self.tb.connect((lms_filter_cc, 0), y_sink) self.tb.connect((lms_filter_cc, 1), e_sink) self.tb.run() throughput_avg = lms_filter_cc.pc_throughput_avg() print("pc_throughput_avg: {0:.3f} MSPS".format(throughput_avg / 1e6))
def test_001_t (self): # Create filters lms_filter_cc = adapt.lms_filter_cc(self.first_input, self.n_taps, self.mu_lms, self.skip, self.decimation, self.adapt, self.reset) y_sink_lms = blocks.vector_sink_c() e_sink_lms = blocks.vector_sink_c() self.tb.connect((lms_filter_cc, 0), y_sink_lms) self.tb.connect((lms_filter_cc, 1), e_sink_lms) nlms_filter_cc = adapt.nlms_filter_cc(self.first_input, self.n_taps, self.mu_nlms, self.skip, self.decimation, self.adapt, self.reset) y_sink_nlms = blocks.vector_sink_c() e_sink_nlms = blocks.vector_sink_c() self.tb.connect((nlms_filter_cc, 0), y_sink_nlms) self.tb.connect((nlms_filter_cc, 1), e_sink_nlms) rls_filter_cc = adapt.rls_filter_cc(self.first_input, self.n_taps, self.delta_rls, self.lambda_rls, self.skip, self.decimation, self.adapt, self.reset) y_sink_rls = blocks.vector_sink_c() e_sink_rls = blocks.vector_sink_c() self.tb.connect((rls_filter_cc, 0), y_sink_rls) self.tb.connect((rls_filter_cc, 1), e_sink_rls) qrd_rls_filter_cc = adapt.qrd_rls_filter_cc(self.n_taps, self.delta_qrd_rls, self.lambda_qrd_rls, self.skip, self.decimation, self.adapt, self.reset) y_sink_qrd_rls = blocks.vector_sink_c() e_sink_qrd_rls = blocks.vector_sink_c() self.tb.connect((qrd_rls_filter_cc, 0), y_sink_qrd_rls) self.tb.connect((qrd_rls_filter_cc, 1), e_sink_qrd_rls) iqrd_rls_filter_cc = adapt.iqrd_rls_filter_cc(self.n_taps, self.delta_iqrd_rls, self.lambda_iqrd_rls, self.skip, self.decimation, self.adapt, self.reset) y_sink_iqrd_rls = blocks.vector_sink_c() e_sink_iqrd_rls = blocks.vector_sink_c() self.tb.connect((iqrd_rls_filter_cc, 0), y_sink_iqrd_rls) self.tb.connect((iqrd_rls_filter_cc, 1), e_sink_iqrd_rls) # Channel model W = 3.1 h = np.zeros(4) h[1:4] = 0.5 * (1 + np.cos(2*np.pi/W * np.linspace(-1,1,3))) for i in range(0, self.n_ensemble): # Set taps to zero lms_filter_cc.set_taps(np.zeros(self.n_taps, dtype=np.complex128)) nlms_filter_cc.set_taps(np.zeros(self.n_taps, dtype=np.complex128)) rls_filter_cc.set_taps(np.zeros(self.n_taps, dtype=np.complex128)) qrd_rls_filter_cc.set_taps(np.zeros(self.n_taps, dtype=np.complex128)) iqrd_rls_filter_cc.set_taps(np.zeros(self.n_taps, dtype=np.complex128)) # Some useful signal to be transmitted np.random.seed(i) d = np.zeros(self.n_samples, dtype=np.complex128) d.real = np.random.randint(2, size=self.n_samples)*2-1 # Random bipolar (-1,1) sequence d.imag = np.random.randint(2, size=self.n_samples)*2-1 u = np.convolve(d, h, mode='valid') # Distorted signal u += np.random.normal(0, np.sqrt(0.001), u.size) # Received signal d_source = blocks.vector_source_c(d.tolist()) u_source = blocks.vector_source_c(u.tolist()) self.tb.connect(d_source, (lms_filter_cc, 0)) self.tb.connect(u_source, (lms_filter_cc, 1)) self.tb.connect(d_source, (nlms_filter_cc, 0)) self.tb.connect(u_source, (nlms_filter_cc, 1)) self.tb.connect(d_source, (rls_filter_cc, 0)) self.tb.connect(u_source, (rls_filter_cc, 1)) self.tb.connect(d_source, (qrd_rls_filter_cc, 0)) self.tb.connect(u_source, (qrd_rls_filter_cc, 1)) self.tb.connect(d_source, (iqrd_rls_filter_cc, 0)) self.tb.connect(u_source, (iqrd_rls_filter_cc, 1)) self.tb.run() self.tb.disconnect(d_source, (lms_filter_cc, 0)) self.tb.disconnect(u_source, (lms_filter_cc, 1)) self.tb.disconnect(d_source, (nlms_filter_cc, 0)) self.tb.disconnect(u_source, (nlms_filter_cc, 1)) self.tb.disconnect(d_source, (rls_filter_cc, 0)) self.tb.disconnect(u_source, (rls_filter_cc, 1)) self.tb.disconnect(d_source, (qrd_rls_filter_cc, 0)) self.tb.disconnect(u_source, (qrd_rls_filter_cc, 1)) self.tb.disconnect(d_source, (iqrd_rls_filter_cc, 0)) self.tb.disconnect(u_source, (iqrd_rls_filter_cc, 1)) e_data_lms = (np.abs(e_sink_lms.data()) ** 2).reshape((self.n_ensemble, self.n_samples-h.size)) e_data_nlms = (np.abs(e_sink_nlms.data()) ** 2).reshape((self.n_ensemble, self.n_samples-h.size)) e_data_rls = (np.abs(e_sink_rls.data()) ** 2).reshape((self.n_ensemble, self.n_samples-h.size)) e_data_qrd_rls = (np.abs(e_sink_qrd_rls.data()) ** 2).reshape((self.n_ensemble, self.n_samples-h.size)) e_data_iqrd_rls = (np.abs(e_sink_iqrd_rls.data()) ** 2).reshape((self.n_ensemble, self.n_samples-h.size)) e_data_lms = np.mean(e_data_lms, axis=0) e_data_nlms = np.mean(e_data_nlms, axis=0) e_data_rls = np.mean(e_data_rls, axis=0) e_data_qrd_rls = np.mean(e_data_qrd_rls, axis=0) e_data_iqrd_rls = np.mean(e_data_iqrd_rls, axis=0) if self.plot_enabled: plt.figure(figsize=(5, 4)) plt.rc('axes', prop_cycle=(cycler('color', ['r', 'g', 'b', 'k', 'm']))) plt.title("Learning curves for different algorithms") plt.xlabel("Number of iterations") plt.ylabel("Ensemble-averaged square error") plt.semilogy(e_data_lms, label=u"LMS (μ={})".format(self.mu_lms)) plt.semilogy(e_data_nlms, label=u"NLMS (μ={})".format(self.mu_nlms)) plt.semilogy(e_data_rls, label=u"RLS (δ={}, λ={})".format(self.delta_rls, self.lambda_rls)) plt.semilogy(e_data_qrd_rls, label=u"QRD RLS (δ={}, λ={})".format(self.delta_qrd_rls, self.lambda_qrd_rls)) plt.semilogy(e_data_iqrd_rls, label=u"IQRD RLS (δ={}, λ={})".format(self.delta_iqrd_rls, self.lambda_iqrd_rls)) plt.legend() plt.grid() plt.tight_layout() plt.show()
def test_001_t(self): # Create float filters filters_ff = [] lms_filter_ff = adapt.lms_filter_ff(self.first_input, self.n_taps, self.mu_lms, self.skip, self.decimation, self.adapt, self.reset) filters_ff.append(lms_filter_ff) nlms_filter_ff = adapt.nlms_filter_ff(self.first_input, self.n_taps, self.mu_nlms, self.skip, self.decimation, self.adapt, self.reset) filters_ff.append(nlms_filter_ff) rls_filter_ff = adapt.rls_filter_ff(self.first_input, self.n_taps, self.delta_rls, self.lambda_rls, self.skip, self.decimation, self.adapt, self.reset) filters_ff.append(rls_filter_ff) qrd_rls_filter_ff = adapt.qrd_rls_filter_ff(self.n_taps, self.delta_qrd_rls, self.lambda_qrd_rls, self.skip, self.decimation, self.adapt, self.reset) filters_ff.append(qrd_rls_filter_ff) iqrd_rls_filter_ff = adapt.iqrd_rls_filter_ff( self.n_taps, self.delta_iqrd_rls, self.lambda_iqrd_rls, self.skip, self.decimation, self.adapt, self.reset) filters_ff.append(iqrd_rls_filter_ff) y_sink_f = blocks.vector_sink_f() e_sink_f = blocks.vector_sink_f() # Create complex filters filters_cc = [] lms_filter_cc = adapt.lms_filter_cc(self.first_input, self.n_taps, self.mu_lms, self.skip, self.decimation, self.adapt, self.reset) filters_cc.append(lms_filter_cc) nlms_filter_cc = adapt.nlms_filter_cc(self.first_input, self.n_taps, self.mu_nlms, self.skip, self.decimation, self.adapt, self.reset) filters_cc.append(nlms_filter_cc) rls_filter_cc = adapt.rls_filter_cc(self.first_input, self.n_taps, self.delta_rls, self.lambda_rls, self.skip, self.decimation, self.adapt, self.reset) filters_cc.append(rls_filter_cc) qrd_rls_filter_cc = adapt.qrd_rls_filter_cc(self.n_taps, self.delta_qrd_rls, self.lambda_qrd_rls, self.skip, self.decimation, self.adapt, self.reset) filters_cc.append(qrd_rls_filter_cc) iqrd_rls_filter_cc = adapt.iqrd_rls_filter_cc( self.n_taps, self.delta_iqrd_rls, self.lambda_iqrd_rls, self.skip, self.decimation, self.adapt, self.reset) filters_cc.append(iqrd_rls_filter_cc) y_sink_c = blocks.vector_sink_c() e_sink_c = blocks.vector_sink_c() results_f = [] results_c = [] names = [] # Channel model W = 3.1 h = np.zeros(4) h[1:4] = 0.5 * (1 + np.cos(2 * np.pi / W * np.linspace(-1, 1, 3))) # Some useful signal to be transmitted np.random.seed(2701) d = np.random.randint( 2, size=self.n_samples) * 2 - 1 # Random bipolar (-1,1) sequence u = np.convolve(d, h, mode='valid') # Distorted signal u += np.random.normal(0, np.sqrt(0.001), u.size) # Received signal np.random.seed(2701) d_c = np.empty(self.n_samples, dtype=np.complex64) d_c.real = np.random.randint( 2, size=self.n_samples) * 2 - 1 # Random bipolar (-1,1) sequence d_c.imag = np.random.randint(2, size=self.n_samples) * 2 - 1 u_c = np.convolve(d_c, h, mode='valid') # Distorted signal u_c += np.random.normal(0, np.sqrt(0.001), u_c.size) # Received signal for filter_ff in filters_ff: d_source = blocks.vector_source_f(d.tolist()) u_source = blocks.vector_source_f(u.tolist()) self.tb.connect(d_source, (filter_ff, 0)) self.tb.connect(u_source, (filter_ff, 1)) self.tb.connect((filter_ff, 0), y_sink_f) self.tb.connect((filter_ff, 1), e_sink_f) self.tb.run() results_f.append(filter_ff.pc_throughput_avg() / 1e6) names.append( str(filter_ff.__class__.__name__).replace('_ff_sptr', '')) self.tb.disconnect(filter_ff) for filter_cc in filters_cc: d_source = blocks.vector_source_c(d_c.tolist()) u_source = blocks.vector_source_c(u_c.tolist()) self.tb.connect(d_source, (filter_cc, 0)) self.tb.connect(u_source, (filter_cc, 1)) self.tb.connect((filter_cc, 0), y_sink_c) self.tb.connect((filter_cc, 1), e_sink_c) self.tb.run() results_c.append(filter_cc.pc_throughput_avg() / 1e6) # names.append(str(filter_cc.__class__.__name__).replace('_sptr','')) self.tb.disconnect(filter_cc) if self.plot_enabled: # plt.rc('axes', prop_cycle=(cycler('color', ['r', 'g', 'b', 'k']))) fig, ax = plt.subplots(figsize=(5, 4)) index = np.arange(len(names)) # the x locations for the groups width = 0.3 # the width of the bars rects1 = ax.bar(index, results_f, width, label='Float (n={})'.format(self.n_taps)) rects2 = ax.bar(index + width, results_c, width, label='Complex (n={})'.format(self.n_taps)) ax.set_ylabel('Throughput (MSPS)') ax.set_title('Throughput for different algorithms\n{}'.format( cpuinfo.get_cpu_info()['brand'])) ax.set_xticks(index + width / 2) ax.set_xticklabels(names, rotation=45, ha="right") ax.legend() xpos = 'center' xpos = xpos.lower() # normalize the case of the parameter ha = {'center': 'center', 'right': 'left', 'left': 'right'} offset = { 'center': 0.5, 'right': 0.57, 'left': 0.43 } # x_txt = x + w*off for rect in rects1: height = rect.get_height() ax.text(rect.get_x() + rect.get_width() * offset[xpos], 1.01 * height, '{0:.2f}'.format(height), ha=ha[xpos], va='bottom') for rect in rects2: height = rect.get_height() ax.text(rect.get_x() + rect.get_width() * offset[xpos], 1.01 * height, '{0:.2f}'.format(height), ha=ha[xpos], va='bottom') fig.tight_layout() plt.show()
def test_001_t(self): ''' Simulate convergence for different channel models. :return: ''' # Channel model W = [2.9, 3.1, 3.3, 3.5] h = np.zeros((len(W), 4)) for j, Wj in enumerate(W): h[j][1:4] = 0.5 * (1 + np.cos(2 * np.pi / Wj * np.linspace(-1, 1, 3))) # Filters lms_filter_cc = [] y_sink_lms = [] e_sink_lms = [] for j, _ in enumerate(W): lms_filter_cc.append( adapt.lms_filter_cc(True, self.n_taps, self.mu, self.skip, self.decimation, self.adapt, self.reset)) y_sink_lms.append(blocks.vector_sink_c()) e_sink_lms.append(blocks.vector_sink_c()) self.tb.connect((lms_filter_cc[j], 0), y_sink_lms[j]) self.tb.connect((lms_filter_cc[j], 1), e_sink_lms[j]) for i in range(0, self.n_ensemble): # Set taps to zero for j in range(0, len(W)): lms_filter_cc[j].set_taps( np.zeros(self.n_taps, dtype=np.complex128)) # Some useful signal to be transmitted np.random.seed(i) d = np.zeros(self.n_samples, dtype=np.complex128) d.real = np.random.randint( 2, size=self.n_samples) * 2 - 1 # Random bipolar (-1,1) sequence d.imag = np.random.randint(2, size=self.n_samples) * 2 - 1 d_source = blocks.vector_source_c(d.tolist()) u = [] u_source = [] for j in range(0, len(W)): u.append(np.convolve(d, h[j], mode='valid')) # Distorted signal u[j] += np.random.normal(0, np.sqrt(0.001), u[j].size) # Received signal u_source.append(blocks.vector_source_c(u[j].tolist())) self.tb.connect(d_source, (lms_filter_cc[j], 0)) self.tb.connect(u_source[j], (lms_filter_cc[j], 1)) self.tb.run() for j in range(0, len(W)): self.tb.disconnect(d_source, (lms_filter_cc[j], 0)) self.tb.disconnect(u_source[j], (lms_filter_cc[j], 1)) e_data_lms = [] for j in range(0, len(W)): e_data_lms.append((np.abs(e_sink_lms[j].data())**2).reshape( (self.n_ensemble, self.n_samples - h[j].size))) e_data_lms[j] = np.mean(e_data_lms[j], axis=0) if self.plot_enabled: plt.figure(figsize=(5, 4)) plt.rc('axes', prop_cycle=(cycler('color', ['r', 'g', 'b', 'k']))) plt.title("Learning curves for LMS algorithm") plt.xlabel("Number of iterations") plt.ylabel("Ensemble-averaged square error") for j in range(0, len(W)): plt.semilogy(e_data_lms[j], label="W={}".format(W[j])) plt.legend() plt.grid() plt.tight_layout() plt.show()
def test_004_t(self): ''' Check if decimation works. :return: ''' # Overwrite variables self.n_samples = 1024 self.decimation = 2 # Create signal Fs = 2e6 Fc = 100e3 phaseAcc = 0 phaseInc = 2 * np.pi * Fc / Fs phaseAccNext = phaseAcc + self.n_samples * phaseInc d = 1 * np.sin(np.linspace(phaseAcc, phaseAccNext, self.n_samples)).astype(np.float32) # Channel model W = 2.9 h = np.zeros(4) h[1:4] = 0.5 * (1 + np.cos(2 * np.pi / W * np.linspace(-1, 1, 3))) u = np.convolve(d, h, mode='valid') # Distorted signal u += np.random.normal(0, np.sqrt(0.001), u.size) # Received signal d_source = blocks.vector_source_c(d.tolist()) u_source = blocks.vector_source_c(u.tolist()) lms_filter_cc = adapt.lms_filter_cc(True, self.n_taps, self.mu, self.skip, self.decimation, self.adapt, self.reset) y_sink = blocks.vector_sink_c() e_sink = blocks.vector_sink_c() self.tb.connect(d_source, (lms_filter_cc, 0)) self.tb.connect(u_source, (lms_filter_cc, 1)) self.tb.connect((lms_filter_cc, 0), y_sink) self.tb.connect((lms_filter_cc, 1), e_sink) self.tb.run() y_data = np.array(y_sink.data()) e_data = np.abs(e_sink.data()) m = np.median(e_data[e_data > 0]) e_data[e_data == 0] = m plt.figure(figsize=(15, 9)) plt.subplot(211) plt.title("Adaptation") plt.xlabel("samples - k") plt.plot(np.delete(d, np.arange(0, d.size, 2)), "b", label="d - reference") plt.plot(np.delete(u, np.arange(0, u.size, 2)), "r", label="u - input") plt.plot(y_data, "g", label="y - output") plt.legend() plt.subplot(212) plt.title("Filter error") plt.xlabel("samples - k") plt.plot(10 * np.log10(e_data**2), "r", label="e - error [dB]") plt.legend() plt.tight_layout() plt.show()