Python/Masterarbeit_Simulation
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
192feb9df861fef24f7d2a3a882b1c8a4f161354
Masterarbeit_Simulation/ANR_high_level.ipynb
T
Patrick Hangl 192feb9df8 Zweite ANR-Umsetzung eingepflegt, Delay funktioniert
2026-03-24 16:54:34 +01:00

1004 lines
42 KiB
Plaintext
Raw Blame History

{
"cells": [
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"#Funktionen und Abhängigkeiten\n",
"\n",
"import time\n",
"import os\n",
"from ipywidgets import interact\n",
"from scipy import signal\n",
"from scipy.signal import savgol_filter\n",
"from scipy.stats import pearsonr\n",
"import numpy as np\n",
"import matplotlib.pyplot as plt\n",
"import soundfile as sf\n",
"import pandas as pd\n",
"import csv\n",
"\n",
"# Soundfile laden\n",
"def load_wav(filename):\n",
" y, fs = sf.read(filename, dtype='float32')\n",
" return fs, y.T\n",
"\n",
"# Sensitivätskurve Mikrofon laden (normiert auf 1000 Hz)\n",
"def load_transfer_function(filename):\n",
" df = pd.read_csv(filename, skiprows=3, header=None, dtype=float, sep=\";\")\n",
" frequencies = df.iloc[:, 0]\n",
" gain = df.iloc[:, 1]\n",
" return frequencies, gain\n",
"\n",
"# Transferfunktion für frequenzabhängige Veränderung von Signal anlegen\n",
"def apply_transfer_function_freq(signal, fs, frequencies, gain_dB):\n",
" # Signal in Frequenzbereich fouriertransformieren, Frequenzbins berechnen, linearen Gain berechnen\n",
" N = len(signal)\n",
" freq_signal = np.fft.rfft(signal)\n",
" freq_bins = np.fft.rfftfreq(N, d=1/fs)\n",
" gain_linear = 10 ** (gain_dB / 20.0) \n",
" # Gain Werte interpolieren auf die tatsächlichen Frequenzbins\n",
" # Phasenshift für die Verzögerung berechnen\n",
" # Signalfrequenzen modifizieren. \n",
" # Signal wieder zurück in Zeitbereich\n",
" gain_interp = np.interp(freq_bins, frequencies, gain_linear)\n",
" modified_freq_signal = freq_signal * gain_interp\n",
" modified_signal = np.fft.irfft(modified_freq_signal, n=N)\n",
" return modified_signal\n",
"\n",
"# High-Level ANR Algorithmmus\n",
"def anr_function(input, ref_noise, coefficients, mu, adaption_step = 1):\n",
" coefficient_matrix = np.zeros((len(input), coefficients), dtype=np.float32)\n",
" output=np.zeros(input.shape[0], dtype=np.float32)\n",
" filter = np.zeros(coefficients, dtype=np.float32)\n",
" adaption_step = 1\n",
" \n",
" for j in range(0, len(input) - len(filter)): \n",
" accumulator=0\n",
" for i in range(coefficients):\n",
" noise=ref_noise[j+i]\n",
" accumulator+=filter[i] * noise\n",
" output[j] = input[j] - accumulator\n",
" corrector = mu * output[j]\n",
" if (j % adaption_step) == 0:\n",
" for k in range(coefficients):\n",
" filter[k] += corrector*ref_noise[j+k]\n",
" coefficient_matrix[j, :] = filter[:]\n",
" return output, coefficient_matrix\n",
"\n",
"# Low-Level ANR Algorithmmus (wie in C)\n",
"def anr_function_c(input, ref_noise, coefficients, mu, adaption_step = 1):\n",
" sample_count = len(input)\n",
" filter_line = np.zeros(coefficients)\n",
" sample_line = np.zeros(coefficients)\n",
" output = np.zeros(sample_count)\n",
" coeffient_matrix = np.zeros((sample_count, coefficients))\n",
" \n",
" for n in range(sample_count):\n",
" # Reference Noise Signal in Sample Line\n",
" sample_line = np.roll(sample_line, 1)\n",
" sample_line[0] = ref_noise[n]\n",
" # apply_fir_filter: Akkumulator berechnen\n",
" accumulator = np.dot(filter_line, sample_line)\n",
" # update_output: Output/Error berechnen\n",
" error = input[n] - accumulator\n",
" output[n] = error\n",
" # update_filter_coeffcients: Filterkoeffizienten adaptieren\n",
" filter_line += mu * error * sample_line\n",
" # Filterkoeffizienten expoertieren\n",
" coeffient_matrix[n, :] = filter_line\n",
" return output, coeffient_matrix\n",
"\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"#Plots für Simple Usecases\n",
"\n",
"SIMULATION = True\n",
"AUDIO = False\n",
"PLOT = True\n",
"COMPLEX = True\n",
"\n",
"plot = 'sine_1'\n",
"\n",
"# Chirp Generator\n",
"n=2000 #Sampleanzahl\n",
"fs=20000 #Samplingrate\n",
"f0=100 #Startfrequenz\n",
"f1=1000 #Stopfrequenz\n",
"t1=n/fs #Chirpdauer (Samples/Samplingrate)\n",
"if plot == 'sine_1':\n",
" f_disturber=2000 #Störfrequenz\n",
"else:\n",
" f_disturber=500 #Störfrequenz\n",
"\n",
"signal_amplitude=0.5\n",
"disturber_amplitude=0.25\n",
"\n",
"# Parameter setzen\n",
"coefficients = 16\n",
"step_size = 0.01\n",
"noise_delay = 0.000\n",
"indices = [0, coefficients // 2, coefficients - 1]\n",
"\n",
"t = np.linspace(0, t1, n)\n",
"\n",
"# Zielsignal anlegen\n",
"desired_signal = signal.chirp(t, f0=f0, f1=f1, t1=t1, method='linear')*signal_amplitude\n",
"\n",
"# Störsignal anlegen\n",
"if plot == 'sine_1' or plot == 'sine_2':\n",
" noise_signal = np.sin(2*np.pi*f_disturber*t) * disturber_amplitude\n",
"else:\n",
" noise_signal = np.random.normal(0, 1, n) * disturber_amplitude\n",
"\n",
"# Sensitivätskurve Mikrofon laden (normiert auf 1000 Hz)\n",
"frequency_r11, gain_r11 = load_transfer_function('./transfer_functions/R11_normalized.csv')\n",
"frequency_vpu, gain_vpu = load_transfer_function('./transfer_functions/VPU17BA01_normlized.csv')\n",
"\n",
"if COMPLEX == True:\n",
" desired_signal_r11 = apply_transfer_function_freq(desired_signal, fs, frequency_r11, gain_r11)\n",
" noise_signal_r11 = apply_transfer_function_freq(noise_signal, fs, frequency_r11, gain_r11)\n",
" noise_signal_vpu = apply_transfer_function_freq(noise_signal, fs, frequency_vpu, gain_vpu)\n",
"else:\n",
" desired_signal_r11 = desired_signal\n",
" noise_signal_r11 = noise_signal\n",
" noise_signal_vpu = noise_signal\n",
"\n",
"# Noise Delay bedeutet, dass das Corruption Noise Signal im Corrupted Signal verzögert ist (zum Reference Noise Signal)\n",
"if noise_delay != 0:\n",
" # Delay von ms in Samples umrechnen, 0-Array erzeugen\n",
" delay_samples = int(noise_delay * fs)\n",
" noise_signal_r11_delayed = np.zeros_like(noise_signal_r11)\n",
" # Schneided die Delay Samples vom ursprünglichen Array ab und schreibt sie nach entsprechend vielen Nullen ins neue Array\n",
" noise_signal_r11_delayed[delay_samples:] = noise_signal_r11[:-delay_samples]\n",
" # Corrupted Signal mit verzögertem Noise\n",
" corrupted_signal = desired_signal_r11 + noise_signal_r11_delayed\n",
"else:\n",
" corrupted_signal = desired_signal_r11 + noise_signal_r11\n",
"\n",
"# Zeitachse anlegen, ANR Algorithmus ausführen\n",
"t = np.linspace(0, len(corrupted_signal), len(corrupted_signal))/1000\n",
"output, coefficient_matrix = anr_function_c(corrupted_signal, noise_signal_vpu, coefficients, step_size, adaption_step=1)\n",
"\n",
"# Koeffizientenmatrix und Vergleich um Koeffizientenanzahl kürzen, um Tail zu vermeiden, 2.te Zeitachse anlegen\n",
"coefficient_matrix = coefficient_matrix[:-coefficients]\n",
"error_signal = (output - desired_signal_r11)[:-coefficients]\n",
"t2 = np.linspace(0, len(error_signal), len(error_signal))/20000\n",
"\n",
"# SNR davor/danach in dB berechnen, SNR Ratio berechnen, \n",
"snr_before = 10 * np.log10(np.trapz(desired_signal_r11**2, t) / np.trapz(noise_signal_r11**2, t))\n",
"snr_after = 10 * np.log10(np.trapz(desired_signal_r11**2, t) / np.trapz(error_signal**2, t2))\n",
"delta_snr = round(snr_after - snr_before, 2)\n",
"\n",
"if SIMULATION == True:\n",
" # Soundfiles zu 16 Bit skalieren und als .txt speichern für DSP Simulation\n",
" dsp_desired_signal_r11 = desired_signal_r11*(2**(15)-1)\n",
" dsp_noise_signal_r11 = noise_signal_r11*(2**(15)-1)\n",
" dsp_noise_signal_vpu = noise_signal_vpu*(2**(15)-1)\n",
" dsp_corrupted_signal = dsp_desired_signal_r11 + dsp_noise_signal_r11\n",
" python_output = output*(2**(15)-1)\n",
" np.savetxt('simulation_data/simple_dsp_desired_signal_r11.txt', dsp_desired_signal_r11, fmt='%d')\n",
" np.savetxt('simulation_data/simple_dsp_noise_signal_r11.txt', dsp_noise_signal_r11, fmt='%d')\n",
" np.savetxt('simulation_data/simple_dsp_noise_signal_vpu.txt', dsp_noise_signal_vpu, fmt='%d', delimiter=\"\\n\")\n",
" np.savetxt('simulation_data/simple_dsp_corrupted_signal.txt', dsp_corrupted_signal, fmt='%d', delimiter=\"\\n\")\n",
" np.savetxt('filter_output/simple_python_output.txt', python_output, fmt='%d', delimiter=\"\\n\")\n",
" np.savetxt('filter_output/simple_python_filter_coefficients.txt', coefficient_matrix, fmt='%.4f', delimiter=\",\")\n",
"\n",
"# Plots des Filterprozesses\n",
"figure1, (ax0, ax1, ax2, ax3) = plt.subplots(4, 1, figsize=(15, 12), sharex=True, sharey=True)\n",
"ax0.set_ylim(-1, 1)\n",
"ax0.plot(t, desired_signal, c='deepskyblue', label='Desired signal')\n",
"ax1.plot(t, corrupted_signal, c='royalblue', label='Corrupted signal')\n",
"ax2.plot(t, noise_signal, c='chocolate', label='Reference noise signal')\n",
"ax3.plot(t, output, c='green', label=f'SNR Gain = {delta_snr} dB')\n",
"\n",
"ax0.text(0.5, -0.3, '(a) Desired signal',\n",
" transform=ax0.transAxes,\n",
" fontsize=25,\n",
" fontweight='normal',\n",
" ha='center',\n",
" va='bottom')\n",
"\n",
"ax1.text(0.5, -0.3, '(b) Corrupted signal',\n",
" transform=ax1.transAxes,\n",
" fontsize=25,\n",
" fontweight='normal',\n",
" ha='center',\n",
" va='bottom')\n",
"\n",
"ax2.text(0.5, -0.3, '(c) Reference noise signal',\n",
" transform=ax2.transAxes,\n",
" fontsize=25,\n",
" fontweight='normal',\n",
" ha='center',\n",
" va='bottom')\n",
"\n",
"ax3.text(0.5, -0.5, f'(d) Filter output (SNR Gain = {delta_snr} dB)',\n",
" transform=ax3.transAxes,\n",
" fontsize=25,\n",
" fontweight='normal',\n",
" ha='center',\n",
" va='bottom')\n",
"\n",
"ax3.set_xlabel('time(s)', x=0.05)\n",
"ax0.set_ylabel('Amplitude')\n",
"ax1.set_ylabel('Amplitude')\n",
"ax2.set_ylabel('Amplitude')\n",
"ax3.set_ylabel('Amplitude')\n",
"\n",
"# Plots der Filterperfomanz\n",
"figure2, (ax4, ax5) = plt.subplots(2, 1, figsize=(15, 7), sharex=True)\n",
"ax4.set_ylim(-1, 1)\n",
"ax4.plot(t2, error_signal, c='purple', label='Error (Desired signal - Filter output)')\n",
"for i in indices:\n",
" ax5.plot(t2, coefficient_matrix[:,i], label=f'Coefficient {i+1}')\n",
"\n",
"ax4.text(0.5, -0.3, '(a) Error signal',\n",
" transform=ax4.transAxes,\n",
" fontsize=25,\n",
" fontweight='normal',\n",
" ha='center',\n",
" va='bottom')\n",
"\n",
"ax5.text(0.5, -0.5, '(b) Coefficient values (1st, 8th, 16th)',\n",
" transform=ax5.transAxes,\n",
" fontsize=25,\n",
" fontweight='normal',\n",
" ha='center',\n",
" va='bottom')\n",
"\n",
"ax5.set_xlabel('time(s)', x=0.05)\n",
"ax4.set_ylabel('Amplitude')\n",
"ax5.set_ylabel('Coeffcient value')\n",
"\n",
"#Grids direkt auf Subplots anwenden\n",
"ax0.grid(True, linestyle='--', alpha=0.4)\n",
"ax1.grid(True, linestyle='--', alpha=0.4)\n",
"ax2.grid(True, linestyle='--', alpha=0.4)\n",
"ax3.grid(True, linestyle='--', alpha=0.4)\n",
"ax4.grid(True, linestyle='--', alpha=0.4)\n",
"ax5.grid(True, linestyle='--', alpha=0.4)\n",
"\n",
"#Spines direkt auf Subplots anwenden\n",
"ax0.spines['top'].set_visible(False)\n",
"ax1.spines['top'].set_visible(False)\n",
"ax2.spines['top'].set_visible(False)\n",
"ax3.spines['top'].set_visible(False)\n",
"ax4.spines['top'].set_visible(False)\n",
"ax5.spines['top'].set_visible(False)\n",
"ax0.spines['right'].set_visible(False)\n",
"ax1.spines['right'].set_visible(False)\n",
"ax2.spines['right'].set_visible(False)\n",
"ax3.spines['right'].set_visible(False)\n",
"ax4.spines['right'].set_visible(False)\n",
"ax5.spines['right'].set_visible(False)\n",
"\n",
"# Schriftgrößen für LaTeX-Dokument\n",
"plt.rcParams.update({\n",
" \"text.usetex\": True,\n",
" \"font.family\": \"serif\",\n",
" 'font.size': 16, # Standardtext\n",
" 'axes.labelsize': 30, # Achsenbeschriftungen\n",
" 'xtick.labelsize': 25, # Tick-Beschriftungen\n",
" 'ytick.labelsize': 25,\n",
" 'legend.fontsize': 15 # Legende\n",
"})\n",
"\n",
"figure1.tight_layout()\n",
"figure2.tight_layout()\n",
"if PLOT == True:\n",
" figure1.savefig(f'plots/fig_plot_1_{plot}', dpi=600)\n",
" figure2.savefig(f'plots/fig_plot_2_{plot}', dpi=600)\n",
"plt.show()\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"#Plots für intermediate/komplexen Usecases\n",
"\n",
"from pandas import Series\n",
"\n",
"COMPLEX= True\n",
"SIMULATION = True\n",
"AUDIO = False\n",
"PLOT = False\n",
"SERIES = False\n",
"\n",
"# Chirp Generator\n",
"n=2000 #Sampleanzahl\n",
"fs=20000 #Samplingrate\n",
"f0=100 #Startfrequenz\n",
"f1=1000 #Stopfrequenz\n",
"t1=n/fs #Chirpdauer (Samples/Samplingrate)\n",
"f_disturber=2000 #Störfrequenz\n",
"\n",
"# Parameter setzen\n",
"coefficients = 16\n",
"step_size = 0.01\n",
"noise_delay = 0.000\n",
"indices = [0, coefficients // 2, coefficients - 1]\n",
"\n",
"# .wav File laden, Tonspuren den Signalen zuordnen, Corrputed Target Signal erstellen, Reduced Noise Signal erstellen\n",
"fs, data_1 = load_wav(f'./audio_data/Nutzsignal/male.wav')\n",
"fs, data_2 = load_wav(f'./audio_data/Störsignal/breathing.wav')\n",
"\n",
"# Sensitivätskurve Mikrofon laden (normiert auf 1000 Hz)\n",
"frequency_r11, gain_r11 = load_transfer_function('./transfer_functions/R11_normalized.csv')\n",
"frequency_vpu, gain_vpu = load_transfer_function('./transfer_functions/VPU17BA01_normlized.csv')\n",
"\n",
"# Signale laden und zuordnen\n",
"desired_signal = data_1\n",
"noise_signal = data_2\n",
"if COMPLEX == True:\n",
" desired_signal_r11 = apply_transfer_function_freq(desired_signal, fs, frequency_r11, gain_r11)\n",
" noise_signal_r11 = apply_transfer_function_freq(noise_signal, fs, frequency_r11, gain_r11)\n",
" noise_signal_vpu = apply_transfer_function_freq(noise_signal, fs, frequency_vpu, gain_vpu)\n",
"else:\n",
" desired_signal_r11 = desired_signal\n",
" noise_signal_r11 = noise_signal\n",
" noise_signal_vpu = noise_signal\n",
"\n",
"# Noise Delay bedeutet, dass das Corruption Noise Signal im Corrupted Signal verzögert ist (zum Reference Noise Signal)\n",
"if noise_delay != 0:\n",
" # Delay von ms in Samples umrechnen, 0-Array erzeugen\n",
" delay_samples = int(noise_delay * fs)\n",
" noise_signal_r11_delayed = np.zeros_like(noise_signal_r11)\n",
" # Schneided die Delay Samples vom ursprünglichen Array ab und schreibt sie nach entsprechend vielen Nullen ins neue Array\n",
" noise_signal_r11_delayed[delay_samples:] = noise_signal_r11[:-delay_samples]\n",
" # Corrupted Signal mit verzögertem Noise\n",
" corrupted_signal = desired_signal_r11 + noise_signal_r11_delayed\n",
"else:\n",
" corrupted_signal = desired_signal_r11 + noise_signal_r11\n",
"\n",
"# Zeitachse anlegen, ANR Algorithmus ausführen\n",
"t = np.linspace(0, len(corrupted_signal), len(corrupted_signal))/20000\n",
"\n",
"if SERIES == True:\n",
" for i in range(16, coefficients+2, 2):\n",
" output, coefficient_matrix = anr_function_c(corrupted_signal, noise_signal_vpu, i, step_size, adaption_step=1)\n",
"\n",
" # Koeffizientenmatrix und Vergleich um Koeffizientenanzahl kürzen, um Tail zu vermeiden, 2.te Zeitachse anlegen\n",
" coefficient_matrix = coefficient_matrix[:-coefficients]\n",
" error_signal = (output - desired_signal_r11)[:-coefficients]\n",
" t2 = np.linspace(0, len(error_signal), len(error_signal))/20000\n",
"\n",
" # SNR davor/danach in dB berechnen, SNR Ratio berechnen, \n",
" snr_before = 10 * np.log10(np.trapz(desired_signal_r11**2, t) / np.trapz(noise_signal_r11**2, t))\n",
" snr_after = 10 * np.log10(np.trapz(desired_signal_r11**2, t) / np.trapz(error_signal**2, t2))\n",
" delta_snr = round(snr_after - snr_before, 2)\n",
"\n",
" with open('snr_evaluation/male+breathing', 'a', newline='') as f:\n",
" writer = csv.writer(f)\n",
" writer.writerow([i, delta_snr])\n",
"else:\n",
" output, coefficient_matrix = anr_function_c(corrupted_signal, noise_signal_vpu, coefficients, step_size, adaption_step=1)\n",
"\n",
"# Koeffizientenmatrix und Vergleich um Koeffizientenanzahl kürzen, um Tail zu vermeiden, 2.te Zeitachse anlegen\n",
"coefficient_matrix = coefficient_matrix[:-coefficients]\n",
"error_signal = (output - desired_signal_r11)[:-coefficients]\n",
"t2 = np.linspace(0, len(error_signal), len(error_signal))/20000\n",
"\n",
"# SNR davor/danach in dB berechnen, SNR Ratio berechnen, \n",
"snr_before = 10 * np.log10(np.trapz(desired_signal_r11**2, t) / np.trapz(noise_signal_r11**2, t))\n",
"snr_after = 10 * np.log10(np.trapz(desired_signal_r11**2, t) / np.trapz(error_signal**2, t2))\n",
"delta_snr = round(snr_after - snr_before, 2)\n",
"\n",
"if AUDIO == True:\n",
" # Audiodateien zum Vergleich abspeichern\n",
" sf.write('corrupted_signal.wav', corrupted_signal, fs)\n",
" sf.write('filter_output.wav', output, fs)\n",
"\n",
"if SIMULATION == True:\n",
" # Soundfiles zu 16 Bit skalieren und als .txt speichern für DSP Simulation\n",
" dsp_desired_signal_r11 = desired_signal_r11*(2**(15)-1)\n",
" dsp_noise_signal_r11 = noise_signal_r11*(2**(15)-1)\n",
" dsp_noise_signal_vpu = noise_signal_vpu*(2**(15)-1)\n",
" dsp_corrupted_signal = dsp_desired_signal_r11 + dsp_noise_signal_r11\n",
" python_output = output*(2**(15)-1)\n",
" python_coefficient_matrix = coefficient_matrix*(2**(15)-1)\n",
" np.savetxt('simulation_data/complex_dsp_desired_signal_r11.txt', dsp_desired_signal_r11, fmt='%d')\n",
" np.savetxt('simulation_data/complex_dsp_noise_signal_r11.txt', dsp_noise_signal_r11, fmt='%d')\n",
" np.savetxt('simulation_data/complex_dsp_noise_signal_vpu.txt', dsp_noise_signal_vpu, fmt='%d', delimiter=\"\\n\")\n",
" np.savetxt('simulation_data/complex_dsp_corrupted_signal.txt', dsp_corrupted_signal, fmt='%d', delimiter=\"\\n\")\n",
" np.savetxt('filter_output/complex_python_output.txt', python_output, fmt='%d', delimiter=\"\\n\")\n",
" np.savetxt('filter_output/complex_python_filter_coefficients.txt', python_coefficient_matrix, fmt='%d', delimiter=\",\")\n",
"\n",
"# Plots des Filterprozesses\n",
"figure1, (ax0, ax1, ax2, ax3) = plt.subplots(4, 1, figsize=(15, 12), sharex=True, sharey=True)\n",
"ax0.set_ylim(-1, 1)\n",
"ax0.plot(t, desired_signal, c='deepskyblue', label='Desired signal')\n",
"ax1.plot(t, corrupted_signal, c='royalblue', label='Corrupted signal')\n",
"ax2.plot(t, noise_signal_vpu, c='chocolate', label='Reference noise signal')\n",
"ax3.plot(t, output, c='green', label=f'SNR Gain = {delta_snr} dB')\n",
"\n",
"ax0.text(0.5, -0.3, '(a) Desired signal',\n",
" transform=ax0.transAxes,\n",
" fontsize=25,\n",
" fontweight='normal',\n",
" ha='center',\n",
" va='bottom')\n",
"\n",
"ax1.text(0.5, -0.3, '(b) Corrupted signal',\n",
" transform=ax1.transAxes,\n",
" fontsize=25,\n",
" fontweight='normal',\n",
" ha='center',\n",
" va='bottom')\n",
"\n",
"ax2.text(0.5, -0.3, '(c) Reference noise signal',\n",
" transform=ax2.transAxes,\n",
" fontsize=25,\n",
" fontweight='normal',\n",
" ha='center',\n",
" va='bottom')\n",
"\n",
"ax3.text(0.5, -0.5, f'(d) Filter output (SNR Gain = {delta_snr} dB)',\n",
" transform=ax3.transAxes,\n",
" fontsize=25,\n",
" fontweight='normal',\n",
" ha='center',\n",
" va='bottom')\n",
"\n",
"ax3.set_xlabel('time(s)', x=0.05)\n",
"ax0.set_ylabel('Amplitude')\n",
"ax1.set_ylabel('Amplitude')\n",
"ax2.set_ylabel('Amplitude')\n",
"ax3.set_ylabel('Amplitude')\n",
"\n",
"# Plots der Filterperfomanz\n",
"figure2, (ax4, ax5) = plt.subplots(2, 1, figsize=(15, 7), sharex=True)\n",
"ax4.set_ylim(-1, 1)\n",
"ax4.plot(t2, error_signal, c='purple', label='Error (Desired signal - Filter output)')\n",
"for i in indices:\n",
" ax5.plot(t2, coefficient_matrix[:,i], label=f'Coefficient {i+1}')\n",
"\n",
"ax4.text(0.5, -0.3, '(a) Error signal',\n",
" transform=ax4.transAxes,\n",
" fontsize=25,\n",
" fontweight='normal',\n",
" ha='center',\n",
" va='bottom')\n",
"\n",
"ax5.text(0.5, -0.5, '(b) Coefficient values (1st, 8th, 16th)',\n",
" transform=ax5.transAxes,\n",
" fontsize=25,\n",
" fontweight='normal',\n",
" ha='center',\n",
" va='bottom')\n",
"\n",
"ax5.set_xlabel('time(s)', x=0.05)\n",
"ax4.set_ylabel('Amplitude')\n",
"ax5.set_ylabel('Coeffcient value')\n",
"\n",
"# Plot Sensitivitätskurve\n",
"figure3, (ax6, ax7) = plt.subplots(2, 1, figsize=(15, 7), sharex=True)\n",
"ax6.set_ylim(min(gain_r11), max(gain_r11))\n",
"ax7.set_ylim(min(gain_vpu), max(gain_vpu))\n",
"ax6.plot(frequency_r11, gain_r11, c='indianred', label='Sensitivity Curve (Primary sensor)' )\n",
"ax7.plot(frequency_vpu, gain_vpu, c='orangered', label='Sensitivity Curve (Secondary sensor)')\n",
"\n",
"ax6.text(0.5, -0.3, '(a) Sensitivity Curve (Primary sensor)',\n",
" transform=ax6.transAxes,\n",
" fontsize=25,\n",
" fontweight='normal',\n",
" ha='center',\n",
" va='bottom')\n",
"ax7.text(0.5, -0.5, '(b) Sensitivity Curve (Secondary sensor)',\n",
" transform=ax7.transAxes,\n",
" fontsize=25,\n",
" fontweight='normal',\n",
" ha='center',\n",
" va='bottom')\n",
"\n",
"ax7.set_xlabel('Frequency (Hz)', x=0.1)\n",
"ax6.set_ylabel('Gain (dB)')\n",
"ax7.set_ylabel('Gain (dB)')\n",
"\n",
"# Plot für Störsignalvergleich\n",
"figure4, (ax8, ax9, ax10) = plt.subplots(3, 1, figsize=(15, 10), sharex=True, sharey=True)\n",
"ax8.set_ylim(1.0, -1.0)\n",
"ax8.plot(t, noise_signal, c='orange', label='Noise signal')\n",
"ax9.plot(t, noise_signal_r11, c='darkorange', label='Corruption noise signal (Primary sensor)')\n",
"ax10.plot(t, noise_signal_vpu, c='peru', label='Reference noise signal (Secondary sensor)')\n",
"\n",
"ax8.text(0.5, -0.3, '(a) Noise signal',\n",
" transform=ax8.transAxes,\n",
" fontsize=25,\n",
" fontweight='normal',\n",
" ha='center',\n",
" va='bottom')\n",
"\n",
"ax9.text(0.5, -0.3, '(b) Corruption noise signal (Primary sensor)',\n",
" transform=ax9.transAxes,\n",
" fontsize=25,\n",
" fontweight='normal',\n",
" ha='center',\n",
" va='bottom')\n",
"\n",
"ax10.text(0.5, -0.5, '(c) Reference noise signal (Secondary sensor)',\n",
" transform=ax10.transAxes,\n",
" fontsize=25,\n",
" fontweight='normal',\n",
" ha='center',\n",
" va='bottom')\n",
"\n",
"ax10.set_xlabel('time(s)', x=0.05)\n",
"ax8.set_ylabel('Amplitude')\n",
"ax9.set_ylabel('Amplitude')\n",
"ax10.set_ylabel('Amplitude')\n",
"\n",
"#Grids direkt auf Subplots anwenden\n",
"ax0.grid(True, linestyle='--', alpha=0.4)\n",
"ax1.grid(True, linestyle='--', alpha=0.4)\n",
"ax2.grid(True, linestyle='--', alpha=0.4)\n",
"ax3.grid(True, linestyle='--', alpha=0.4)\n",
"ax4.grid(True, linestyle='--', alpha=0.4)\n",
"ax5.grid(True, linestyle='--', alpha=0.4)\n",
"ax6.grid(True, linestyle='--', alpha=0.4)\n",
"ax7.grid(True, linestyle='--', alpha=0.4)\n",
"ax8.grid(True, linestyle='--', alpha=0.4)\n",
"ax9.grid(True, linestyle='--', alpha=0.4)\n",
"ax10.grid(True, linestyle='--', alpha=0.4)\n",
"\n",
"#Spines direkt auf Subplots anwenden\n",
"ax0.spines['top'].set_visible(False)\n",
"ax1.spines['top'].set_visible(False)\n",
"ax2.spines['top'].set_visible(False)\n",
"ax3.spines['top'].set_visible(False)\n",
"ax4.spines['top'].set_visible(False)\n",
"ax5.spines['top'].set_visible(False)\n",
"ax6.spines['top'].set_visible(False)\n",
"ax7.spines['top'].set_visible(False)\n",
"ax8.spines['top'].set_visible(False)\n",
"ax9.spines['top'].set_visible(False)\n",
"ax10.spines['top'].set_visible(False)\n",
"ax0.spines['right'].set_visible(False)\n",
"ax1.spines['right'].set_visible(False)\n",
"ax2.spines['right'].set_visible(False)\n",
"ax3.spines['right'].set_visible(False)\n",
"ax4.spines['right'].set_visible(False)\n",
"ax5.spines['right'].set_visible(False)\n",
"ax6.spines['right'].set_visible(False)\n",
"ax7.spines['right'].set_visible(False)\n",
"ax8.spines['right'].set_visible(False)\n",
"ax9.spines['right'].set_visible(False)\n",
"ax10.spines['right'].set_visible(False)\n",
"\n",
"# Schriftgrößen für LaTeX-Dokument\n",
"plt.rcParams.update({\n",
" \"text.usetex\": True,\n",
" \"font.family\": \"serif\",\n",
" 'font.size': 16, # Standardtext\n",
" 'axes.labelsize': 30, # Achsenbeschriftungen\n",
" 'xtick.labelsize': 25, # Tick-Beschriftungen\n",
" 'ytick.labelsize': 25,\n",
" 'legend.fontsize': 15 # Legende\n",
"})\n",
"\n",
"figure1.tight_layout()\n",
"figure2.tight_layout()\n",
"figure3.tight_layout()\n",
"figure4.tight_layout()\n",
"if PLOT == True:\n",
" if COMPLEX == True:\n",
" figure1.savefig(f'plots/fig_plot_1_wav_complex', dpi=600)\n",
" figure2.savefig(f'plots/fig_plot_2_wav_complex', dpi=600)\n",
" figure3.savefig(f'plots/fig_plot_3_wav_complex', dpi=600)\n",
" figure4.savefig(f'plots/fig_plot_4_wav_complex', dpi=600)\n",
" else:\n",
" figure1.savefig(f'plots/fig_plot_1_wav', dpi=600)\n",
" figure2.savefig(f'plots/fig_plot_2_wav', dpi=600)\n",
"plt.show()"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"#Plots für SNR Vergleich\n",
"\n",
"PLOT = True\n",
"\n",
"# Daten aus .csv laden\n",
"data_male_breathing = np.loadtxt('snr_evaluation/male+breathing', delimiter=\",\")\n",
"data_male_chewing = np.loadtxt('snr_evaluation/male+chewing', delimiter=\",\")\n",
"data_male_scratching = np.loadtxt('snr_evaluation/male+scratching', delimiter=\",\")\n",
"data_male_drinking = np.loadtxt('snr_evaluation/male+drinking', delimiter=\",\")\n",
"data_male_coughing = np.loadtxt('snr_evaluation/male+coughing', delimiter=\",\")\n",
"\n",
"\n",
"# Daten laden\n",
"x = data_male_breathing[:, 0]\n",
"male_breathing = savgol_filter(data_male_breathing[:, 1], 10, 3)\n",
"male_chewing = savgol_filter(data_male_chewing[:, 1], 10, 3)\n",
"male_scratching = savgol_filter(data_male_scratching[:, 1], 10, 3)\n",
"male_drinking = savgol_filter(data_male_drinking[:, 1], 10, 3)\n",
"male_coughing = savgol_filter(data_male_coughing[:, 1], 10, 3)\n",
"\n",
"# Alle Kurven in ein Array stapeln\n",
"all_curves = np.vstack([\n",
" male_breathing,\n",
" male_chewing,\n",
" male_scratching,\n",
" male_drinking,\n",
" male_coughing\n",
"])\n",
"\n",
"# Punktweiser Mittelwert\n",
"mean_curve = np.mean(all_curves, axis=0)\n",
"\n",
"# Plot\n",
"plt.figure(figsize=(15, 7))\n",
"plt.plot(x, male_breathing, linestyle='-', linewidth=1.5, alpha=0.7, label='Breathing Noise')\n",
"plt.plot(x, male_chewing, linestyle='--', linewidth=1.5, alpha=0.7, label='Chewing Noise')\n",
"plt.plot(x, male_scratching, linestyle='-.', linewidth=1.5, alpha=0.7, label='Scratching Noise')\n",
"plt.plot(x, male_drinking, linestyle=':', linewidth=1.5, alpha=0.7, label='Drinking Noise')\n",
"plt.plot(x, male_coughing, linestyle=(0, (3, 1, 1, 1)), linewidth=1.5, alpha=0.7, label='Coughing Noise')\n",
"plt.plot(x, mean_curve, linestyle='--', color='red', linewidth=2.5, label='Mean SNR-Gain')\n",
"\n",
"plt.rcParams.update({\n",
" \"text.usetex\": True,\n",
" \"font.family\": \"serif\",\n",
" 'font.size': 16, # Standardtext\n",
" 'axes.labelsize': 30, # Achsenbeschriftungen\n",
" 'xtick.labelsize': 25, # Tick-Beschriftungen\n",
" 'ytick.labelsize': 25,\n",
" 'legend.fontsize': 25 # Legende\n",
"})\n",
"\n",
"plt.xlabel(\"Filter length\")\n",
"plt.ylabel(\"SNR-Gain (dB)\")\n",
"plt.grid(True, linestyle='--', alpha=0.4)\n",
"#Spines auf ganzen Plot anwenden\n",
"plt.gca().spines['top'].set_visible(False)\n",
"plt.gca().spines['right'].set_visible(False)\n",
"plt.legend(frameon=False, loc='upper left')\n",
"plt.tight_layout()\n",
"if PLOT == True:\n",
" plt.savefig(f'plots/fig_snr_comparison', dpi=600)\n",
"plt.show()"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"#Plots der Störsignale\n",
"\n",
"PLOT = True\n",
"\n",
"fs, data_1 = load_wav(f'./audio_data/Störsignal/breathing.wav')\n",
"fs, data_2 = load_wav(f'./audio_data/Störsignal/coughing.wav')\n",
"fs, data_3 = load_wav(f'./audio_data/Störsignal/scratching.wav')\n",
"fs, data_4 = load_wav(f'./audio_data/Störsignal/drinking.wav')\n",
"fs, data_5 = load_wav(f'./audio_data/Störsignal/chewing.wav')\n",
"\n",
"t = np.linspace(0, len(data_1), len(data_1))/20000\n",
"\n",
"figure1, (ax1, ax2, ax3, ax4, ax5) = plt.subplots(5, 1, figsize=(15, 15), sharex=True, sharey=True)\n",
"ax1.set_ylim(1.0, -1.0)\n",
"ax1.plot(t, data_1, c='darkorange', label='Breathing Noise')\n",
"ax2.plot(t, data_2, c='indianred', label='Coughing Noise')\n",
"ax3.plot(t, data_3, c='deepskyblue', label='Scratching Noise')\n",
"ax4.plot(t, data_4, c='forestgreen', label='Drinking Noise')\n",
"ax5.plot(t, data_5, c='darkorchid', label='Chewing Noise')\n",
"\n",
"ax1.text(0.5, -0.3, '(a) Breathing Noise',\n",
" transform=ax1.transAxes,\n",
" fontsize=25,\n",
" fontweight='normal',\n",
" ha='center',\n",
" va='bottom')\n",
"\n",
"ax2.text(0.5, -0.3, '(b) Coughing Noise',\n",
" transform=ax2.transAxes,\n",
" fontsize=25,\n",
" fontweight='normal',\n",
" ha='center',\n",
" va='bottom')\n",
"\n",
"ax3.text(0.5, -0.3, '(c) Scratching Noise',\n",
" transform=ax3.transAxes,\n",
" fontsize=25,\n",
" fontweight='normal',\n",
" ha='center',\n",
" va='bottom')\n",
"\n",
"ax4.text(0.5, -0.3, '(d) Drinking Noise',\n",
" transform=ax4.transAxes,\n",
" fontsize=25,\n",
" fontweight='normal',\n",
" ha='center',\n",
" va='bottom')\n",
"\n",
"ax5.text(0.5, -0.5, '(e) Chewing Noise',\n",
" transform=ax5.transAxes,\n",
" fontsize=25,\n",
" fontweight='normal',\n",
" ha='center',\n",
" va='bottom')\n",
"\n",
"ax5.set_xlabel(\"time (s)\", x=0.05)\n",
"ax1.set_ylabel(\"Amplitude\")\n",
"ax2.set_ylabel(\"Amplitude\")\n",
"ax3.set_ylabel(\"Amplitude\")\n",
"ax4.set_ylabel(\"Amplitude\")\n",
"ax5.set_ylabel(\"Amplitude\")\n",
"#ax5.xaxis.set_label_coords(0.5, -0.4)\n",
"\n",
"ax1.grid(True, linestyle='--', alpha=0.4)\n",
"ax2.grid(True, linestyle='--', alpha=0.4)\n",
"ax3.grid(True, linestyle='--', alpha=0.4)\n",
"ax4.grid(True, linestyle='--', alpha=0.4)\n",
"ax5.grid(True, linestyle='--', alpha=0.4)\n",
"\n",
"#Spines direkt auf Subplots anwenden\n",
"ax1.spines['top'].set_visible(False)\n",
"ax2.spines['top'].set_visible(False)\n",
"ax3.spines['top'].set_visible(False)\n",
"ax4.spines['top'].set_visible(False)\n",
"ax5.spines['top'].set_visible(False)\n",
"ax1.spines['right'].set_visible(False)\n",
"ax2.spines['right'].set_visible(False)\n",
"ax3.spines['right'].set_visible(False)\n",
"ax4.spines['right'].set_visible(False)\n",
"ax5.spines['right'].set_visible(False)\n",
"\n",
"# Schriftgrößen für LaTeX-Dokument\n",
"plt.rcParams.update({\n",
" \"text.usetex\": True,\n",
" \"font.family\": \"serif\",\n",
" 'font.size': 16, # Standardtext\n",
" 'axes.labelsize': 30, # Achsenbeschriftungen\n",
" 'xtick.labelsize': 25, # Tick-Beschriftungen\n",
" 'ytick.labelsize': 25,\n",
" 'legend.fontsize': 15 # Legende\n",
"})\n",
"\n",
"figure1.tight_layout()\n",
"if PLOT == True:\n",
" plt.savefig(f'plots/fig_noise_signals', dpi=600)\n",
"figure1.show()"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Filterlänge und Update-Schritte Vergleich\n",
"\n",
"import numpy as np\n",
"import matplotlib.pyplot as plt\n",
"\n",
"PLOT = True\n",
"\n",
"# Filterlänge\n",
"N = np.arange(1, 128)\n",
"# Verschiedene Updateschritte\n",
"U_values = [1, 0.5, 0.25]\n",
"\n",
"C_total_1 = N + (6*N + 8)*U_values[0] + 34\n",
"C_total_2 = N + (6*N + 8)*U_values[1] + 34\n",
"C_total_3 = N + (6*N + 8)*U_values[2] + 34\n",
"\n",
"plt.figure(figsize=(15, 7))\n",
"plt.plot(N, C_total_1, linestyle='-', linewidth=1.5, alpha=0.7, label=f'1/U = {U_values[0]}')\n",
"plt.plot(N, C_total_2, linestyle='--', linewidth=1.5, alpha=0.7, label=f'1/U = {U_values[1]}')\n",
"plt.plot(N, C_total_3, linestyle='-.', linewidth=1.5, alpha=0.7, label=f'1/U = {U_values[2]}')\n",
"\n",
"plt.rcParams.update({\n",
" \"text.usetex\": True,\n",
" \"font.family\": \"serif\",\n",
" 'font.size': 16, # Standardtext\n",
" 'axes.labelsize': 30, # Achsenbeschriftungen\n",
" 'xtick.labelsize': 25, # Tick-Beschriftungen\n",
" 'ytick.labelsize': 25,\n",
" 'legend.fontsize': 25 # Legende\n",
"})\n",
"\n",
"plt.xlabel(\"Filter length\")\n",
"plt.ylabel(\"Cycles/Sample\")\n",
"plt.grid(True, linestyle='--', alpha=0.4)\n",
"#Spines auf ganzen Plot anwenden\n",
"plt.gca().spines['top'].set_visible(False)\n",
"plt.gca().spines['right'].set_visible(False)\n",
"plt.legend(frameon=False, loc='lower right')\n",
"plt.tight_layout()\n",
"if PLOT == True:\n",
" plt.savefig(f'plots/fig_c_total', dpi=600)\n",
"plt.show()"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Vergleich Output High/Low-Level\n",
"\n",
"PLOT = False\n",
"COMPLEX = False\n",
"\n",
"if COMPLEX == True:\n",
" python_output = np.loadtxt('filter_output/complex_python_output.txt', delimiter=\",\")/(2**(15)-1)\n",
" dsp_output = np.loadtxt('filter_output/complex_dsp_output.txt', delimiter=\",\")[:-1]/(2**(15)-1)\n",
"else:\n",
" python_output = np.loadtxt('filter_output/simple_python_output.txt', delimiter=\",\")/(2**(15)-1)\n",
" dsp_output = np.loadtxt('filter_output/simple_dsp_output.txt', delimiter=\",\")[:-1]/(2**(15)-1)\n",
"\n",
"from scipy.stats import pearsonr\n",
"from scipy import signal\n",
"\n",
"# 1. Mean Squared Error (MSE)\n",
"mse = np.mean((python_output - dsp_output) ** 2)\n",
"# 2. Root Mean Squared Error (RMSE)\n",
"rmse = np.sqrt(mse)\n",
"# 3. Mean Absolute Error (MAE)\n",
"mae = np.mean(np.abs(python_output - dsp_output))\n",
"# 4. Pearson Correlation Coefficient (Lineare Korrelation)\n",
"correlation, p_value = pearsonr(python_output, dsp_output)\n",
"# 5. Normalized Mean Squared Error (NMSE) - normalisiert durch Varianz des Referenzsignals\n",
"nmse = np.sum((python_output - dsp_output) ** 2) / np.sum(dsp_output ** 2)\n",
"\n",
"diff = python_output - dsp_output\n",
"if COMPLEX == True:\n",
" t = np.linspace(0, 200000, 200000)/20000\n",
"else:\n",
" t = np.linspace(0, 2000, 2000)/200\n",
"\n",
"figure1, (ax1, ax2, ax3) = plt.subplots(3, 1, figsize=(15, 9), sharex=True, sharey=True)\n",
"ax1.set_ylim(1.0, -1.0)\n",
"ax1.plot(t, python_output, linestyle='-', c='deepskyblue', linewidth=1, alpha=1, label='High Level Simulation')\n",
"ax2.plot(t, dsp_output, linestyle='-', c='indianred', linewidth=1, alpha=1, label='Low Level Simulation')\n",
"ax3.plot(t, python_output, linestyle='-', c='deepskyblue', linewidth=1, alpha=1, label='High Level Simulation')\n",
"ax3.plot(t, dsp_output, linestyle='-', c='indianred', linewidth=1, alpha=0.7, label=f'Low Level Simulation (Mean squared error: {mse:.3f})')\n",
"ax3.plot(t, diff, linestyle='-', c='green', linewidth=1, alpha=0.7, label=f'Difference')\n",
"\n",
"plt.rcParams.update({\n",
" \"text.usetex\": True,\n",
" \"font.family\": \"serif\",\n",
" 'font.size': 16, # Standardtext\n",
" 'axes.labelsize': 30, # Achsenbeschriftungen\n",
" 'xtick.labelsize': 25, # Tick-Beschriftungen\n",
" 'ytick.labelsize': 25,\n",
" 'legend.fontsize': 25 # Legende\n",
"})\n",
"\n",
"ax1.text(0.5, -0.3, '(a) High Level Simulation',\n",
" transform=ax1.transAxes,\n",
" fontsize=25,\n",
" fontweight='normal',\n",
" ha='center',\n",
" va='bottom')\n",
"\n",
"ax2.text(0.5, -0.3, '(b) Low Level Simulation',\n",
" transform=ax2.transAxes,\n",
" fontsize=25,\n",
" fontweight='normal',\n",
" ha='center',\n",
" va='bottom')\n",
"\n",
"ax3.text(0.5, -0.5, f'(c) Comparision High/Low Level Simulation (Mean squared error: {mse:.3f})',\n",
" transform=ax3.transAxes,\n",
" fontsize=25,\n",
" fontweight='normal',\n",
" ha='center',\n",
" va='bottom')\n",
"\n",
"ax3.set_xlabel(\"time (s)\", x=0.05)\n",
"ax1.set_ylabel(\"Amplitude\")\n",
"ax2.set_ylabel(\"Amplitude\")\n",
"ax3.set_ylabel(\"Amplitude\")\n",
"\n",
"ax1.grid(True, linestyle='--', alpha=0.4)\n",
"ax2.grid(True, linestyle='--', alpha=0.4)\n",
"ax3.grid(True, linestyle='--', alpha=0.4)\n",
"\n",
"#Spines direkt auf Subplots anwenden\n",
"ax1.spines['top'].set_visible(False)\n",
"ax2.spines['top'].set_visible(False)\n",
"ax3.spines['top'].set_visible(False)\n",
"ax1.spines['right'].set_visible(False)\n",
"ax2.spines['right'].set_visible(False)\n",
"ax3.spines['right'].set_visible(False)\n",
"\n",
"\n",
"figure1.tight_layout()\n",
"if PLOT == True:\n",
" plt.savefig(f'plots/fig_high_low_comparison', dpi=600)\n",
"figure1.show()\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Reduced Update Plot\n",
"\n",
"import matplotlib.ticker as mtick\n",
"\n",
"PLOT = True\n",
"\n",
"# Daten aus .csv laden\n",
"data_reduced_update = np.loadtxt('snr_evaluation/reduced_update', delimiter=\",\")\n",
"\n",
"# Daten laden\n",
"x = data_reduced_update[:, 0]\n",
"reduced_update = savgol_filter(data_reduced_update[:, 2], 3, 2)\n",
"\n",
"# Plot\n",
"plt.figure(figsize=(15, 7))\n",
"plt.plot(x, reduced_update, linestyle='--', color='indianred', linewidth=2, alpha=0.9, label='SNR-Gain (Male Voice + Breathing Noise)')\n",
"\n",
"plt.rcParams.update({\n",
" \"text.usetex\": True,\n",
" \"font.family\": \"serif\",\n",
" 'font.size': 16, # Standardtext\n",
" 'axes.labelsize': 30, # Achsenbeschriftungen\n",
" 'xtick.labelsize': 25, # Tick-Beschriftungen\n",
" 'ytick.labelsize': 25,\n",
" 'legend.fontsize': 25 # Legende\n",
"})\n",
"\n",
"\n",
"plt.xlabel(\"Update Rate\")\n",
"plt.ylabel(\"Relative SNR-Gain\")\n",
"plt.grid(True, linestyle='-.', alpha=0.4)\n",
"#Spines auf ganzen Plot anwenden\n",
"plt.gca().yaxis.set_major_formatter(mtick.PercentFormatter(1.0))\n",
"plt.gca().spines['top'].set_visible(False)\n",
"plt.gca().spines['right'].set_visible(False)\n",
"plt.gca().invert_xaxis()\n",
"plt.legend(frameon=False, loc='upper right')\n",
"plt.tight_layout()\n",
"if PLOT == True:\n",
" plt.savefig(f'plots/fig_snr_reduced_update', dpi=600)\n",
"plt.show()\n"
]
}
],
"metadata": {
"kernelspec": {
"display_name": ".venv",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.9.13"
}
},
"nbformat": 4,
"nbformat_minor": 2
}
Reference in New Issue View Git Blame Copy Permalink