Projektaufbau – Entrauschungs-KI - Versionsgeschichte

Adrian.klinspon@stud.hshl.de am 4. Februar 2026 um 14:12 Uhr

2026-02-04T14:12:42Z

← Nächstältere Version		Version vom 4. Februar 2026, 14:12 Uhr
Zeile 3:		Zeile 3:
	\|-		\|-

	\| '''Autoren:''' \|\| Fabian Babik, Adrian Klinspon		\| '''Autoren:''' \|\| Fabian Babik, [[Benutzer:Adrian.klinspon@stud.hshl.de\| Adrian Klinspon]]

	\|-		\|-

Adrian.klinspon@stud.hshl.de am 9. Januar 2026 um 08:52 Uhr

2026-01-09T08:52:54Z

← Nächstältere Version		Version vom 9. Januar 2026, 08:52 Uhr
Zeile 1:		Zeile 1:
			{\| class="wikitable"

			\|-

			\| '''Autoren:''' \|\| Fabian Babik, Adrian Klinspon

			\|-

			\| '''Art:''' \|\| [[Signalverarbeitung mit MATLAB und künstlicher Intelligenz (KI) - Praxissemester\|Projekt im Praxissemester]]

			\|-

			\| '''Dauer:''' \|\| 29.09.2025 bis 09.01.2026

			\|-

			\| '''Betreuer:''' \|\| [[Benutzer:Ulrich_Schneider\|Prof. Dr.-Ing. Schneider]]

			\|}

	= Aufbau =		= Aufbau =
	Dieses Projekt implementiert ein Denoising Convolutional Neural Network (DnCNN) in MATLAB unter Verwendung von Residual Learning. Es dient dazu, Bildrauschen aus digitalen Bildern zu entfernen. Im Gegensatz zu klassischen Ansätzen lernt das Netz hierbei das Rauschen selbst (Residual) und subtrahiert es vom Eingangsbild.		Dieses Projekt implementiert ein Denoising Convolutional Neural Network (DnCNN) in MATLAB unter Verwendung von Residual Learning. Es dient dazu, Bildrauschen aus digitalen Bildern zu entfernen. Im Gegensatz zu klassischen Ansätzen lernt das Netz hierbei das Rauschen selbst (Residual) und subtrahiert es vom Eingangsbild.

Adrian.klinspon@stud.hshl.de: /* Rausch-Generator Tool (DnCNNNoise.m) */

2026-01-09T08:49:38Z

Rausch-Generator Tool (DnCNNNoise.m)

← Nächstältere Version		Version vom 9. Januar 2026, 08:49 Uhr
Zeile 205:		Zeile 205:
	</syntaxhighlight>		</syntaxhighlight>

	= Rausch-Generator Tool (<code>~~DnCNNNoise~~.m</code>) =		= Rausch-Generator Tool (<code>addNoise.m</code>) =
	~~Ein Hilfsskript~~, um ~~einen kompletten Ordner von Bildern permanent~~ zu ~~verrauschen, falls Testdaten benötigt werden~~.		Diese Funktion dient der dynamischen Datenaufbereitung (Data Augmentation) während des Trainings. Sie wird vom `imageDatastore` aufgerufen, um jedem sauberen Bild Rauschen hinzuzufügen und das Trainingsziel zu definieren.

	== Funktionsweise ~~& Code~~ ==		== Funktionsweise==
	~~Nutzt eine grafische Oberfläche~~ (~~GUI~~) ~~zur Ordnerauswahl~~ und die ~~Image Processing Toolbox~~ (<code>~~imnoise~~</code>), ~~um mathematisch exaktes~~ Rauschen ~~hinzuzufügen~~.<br>		* '''Input:''' Erwartet ein sauberes Bild (`clean`) und das Flag für Residual Learning (`useResidual`).
	<~~syntaxhighlight lang="matlab"~~>~~% User Interface für Auswahl~~		* '''Dynamisches Rauschen:''' Es wird zufällig (50/50 Chance) zwischen '''Gaußschem Rauschen''' und '''Salt & Pepper''' gewählt.
	~~noiseChoice = questdlg('Which noise for ALL images?', 'Noise Type'~~, ...		* '''Variable Intensität:''' Die Stärke des Rauschens ist nicht statisch, sondern variiert zufällig zwischen 0.01 und 0.10 (`0.01 + rand()*0.09`).
	'~~Salt & Pepper~~', '~~Gaussian~~', '~~Speckle~~', ~~'Gaussian');~~		* '''Residual Learning:'''
			** Ist <code>useResidual = true</code>, berechnet die Funktion die Differenz (<code>noisy - clean</code>). Das Netz lernt also nur, das Rauschen vorherzusagen.
			** Ist <code>useResidual = false</code>, ist das Ziel das saubere Originalbild.
			* '''Output:''' Gibt ein Paar <code>{verrauschtesBild, ZielBild}</code> zurück.

	~~% Rauschen anwenden~~		== Code ==
	~~switch noiseChoice~~		<syntaxhighlight lang="matlab">
	~~case 'Salt & Pepper'~~		function pair = addNoise(clean, useResidual)
	% ~~Fügt "Salz und Pfeffer"~~-~~Rauschen hinzu~~ (~~Dichte:~~ 0~~.05~~)		clean = im2double(clean); % Konvertiert Bild in Double-Format (0 bis 1)
	~~imgNoisy = imnoise~~(~~img, 'salt & pepper', 0.05~~);
	~~case 'Gaussian'~~		% Zufällige Auswahl des Rausch-Typs (50% Chance)
	% ~~Fügt~~ Gaußsches Rauschen ~~hinzu~~ (~~Mittelwert~~ 0~~, Varianz~~ 0.01)		if rand() > 0.5
	~~imgNoisy~~ = imnoise(~~img~~, 'gaussian', 0, 0.01);		% Gaußsches Rauschen mit zufälliger Varianz (0.01 bis 0.10)
	~~case 'Speckle'~~		noisy = imnoise(clean,'gaussian', 0, 0.01 + rand() * 0.09);
	% ~~Fügt multiplikatives~~ Rauschen ~~hinzu~~ (~~Varianz~~ 0.04)		else
	~~imgNoisy~~ = imnoise(~~img~~, '~~speckle~~', 0.04);		% Salt & Pepper Rauschen mit zufälliger Dichte (0.01 bis 0.10)
	end</syntaxhighlight>		noisy = imnoise(clean, 'salt & pepper', 0.01 + rand() * 0.09);
			end

			% Berechnung des Trainingsziels (Target)
			% Wenn useResidual == true: Target = (noisy - clean) -> Nur das Rauschen lernen
			% Wenn useResidual == false: Target = clean -> Das saubere Bild lernen
			target = useResidual * (noisy - clean) + ~useResidual * clean;

			pair = {noisy, target}; % Rückgabe als Paar für den Datastore
			end
			</syntaxhighlight>

	= Quellen =		= Quellen =
	* P. Arbeláez, M. Maire, C. Fowlkes and J. Malik, "Contour Detection and Hierarchical Image Segmentation," in IEEE Transactions on Pattern Analysis and Machine Intelligence, vol. 33, no. 5, pp. 898-916, May 2011, doi: 10.1109/TPAMI.2010.161. keywords: {Image segmentation;Pixel;Detectors;Image edge detection;Humans;Histograms;Benchmark testing;Contour detection;image segmentation;computer vision.}		* P. Arbeláez, M. Maire, C. Fowlkes and J. Malik, "Contour Detection and Hierarchical Image Segmentation," in IEEE Transactions on Pattern Analysis and Machine Intelligence, vol. 33, no. 5, pp. 898-916, May 2011, doi: 10.1109/TPAMI.2010.161. keywords: {Image segmentation;Pixel;Detectors;Image edge detection;Humans;Histograms;Benchmark testing;Contour detection;image segmentation;computer vision.}
	* R. Timofte, S. Gu, J. Wu, L. Van Gool, L. Zhang, M.-H. Yang, M. Haris et al., "NTIRE 2018 Challenge on Single Image Super-Resolution: Methods and Results," in The IEEE Conference on Computer Vision and Pattern Recognition (CVPR) Workshops, June 2018.		* R. Timofte, S. Gu, J. Wu, L. Van Gool, L. Zhang, M.-H. Yang, M. Haris et al., "NTIRE 2018 Challenge on Single Image Super-Resolution: Methods and Results," in The IEEE Conference on Computer Vision and Pattern Recognition (CVPR) Workshops, June 2018.

Adrian.klinspon@stud.hshl.de: /* Evaluierung (DnCnnEval.m) */

2026-01-09T08:45:51Z

Evaluierung (DnCnnEval.m)

← Nächstältere Version		Version vom 9. Januar 2026, 08:45 Uhr
Zeile 112:		Zeile 112:
	</syntaxhighlight>		</syntaxhighlight>

	= Evaluierung (<code>~~DnCnnEval~~.m</code>) =		= Evaluierung (<code>EvalDnCNN.m</code>) =
	Wendet das trainierte Modell auf neue Bilder im Ordner <code>./Testbilder</code> an und speichert die Ergebnisse in einem Unterordner.		Wendet das trainierte Modell auf neue Bilder im Ordner <code>./Testbilder</code> an und speichert die Ergebnisse in einem Unterordner.

Adrian.klinspon@stud.hshl.de: /* Training (DnCnnTrain.m) */

2026-01-09T08:45:34Z

Training (DnCnnTrain.m)

← Nächstältere Version		Version vom 9. Januar 2026, 08:45 Uhr
Zeile 9:		Zeile 9:
	* Parallel Computing Toolbox		* Parallel Computing Toolbox

	= Training (<code>~~DnCnnTrain~~.m</code>)=		= Training (<code>TrainDnCNN.m</code>)=
	Trainiert das neuronale Netz mit Bildern aus dem Ordner <code>./ImagesForTraining</code>. Dieser Ordner enthält die Trainingsdaten, zusammengestellt aus den Datensätzen BSDS500 und DIV2K.		Trainiert das neuronale Netz mit Bildern aus dem Ordner <code>./ImagesForTraining</code>. Dieser Ordner enthält die Trainingsdaten, zusammengestellt aus den Datensätzen BSDS500 und DIV2K.

Adrian.klinspon@stud.hshl.de: /* Evaluierung (DnCnnEval.m) */

2026-01-09T08:33:02Z

Evaluierung (DnCnnEval.m)

← Nächstältere Version		Version vom 9. Januar 2026, 08:33 Uhr
Zeile 113:		Zeile 113:

	= Evaluierung (<code>DnCnnEval.m</code>) =		= Evaluierung (<code>DnCnnEval.m</code>) =
	Wendet das trainierte Modell auf neue Bilder im Ordner <code>./Testbilder</code> an.		Wendet das trainierte Modell auf neue Bilder im Ordner <code>./Testbilder</code> an und speichert die Ergebnisse in einem Unterordner.

	== Funktionsweise ==		== Funktionsweise ==
	* '''Preprocessing:''' Lädt Bilder und konvertiert Graustufenbilder künstlich in 3-Kanal-Bilder (RGB), ~~um die Kompatibilität mit dem~~ Netz ~~zu gewährleisten~~.		* '''Dateimanagement:''' Das Skript sucht automatisch nach diversen Bildformaten (.png, .jpg, .tif, etc.) und erstellt einen Ausgabeordner.
	* '''Rauschen:''' ~~Falls~~ das Bild ~~als "sauber" markiert~~ ist, fügt das Skript automatisch Gaußsches Rauschen hinzu.		* '''Preprocessing:''' Lädt Bilder, wandelt sie in `double` um und konvertiert Graustufenbilder künstlich in 3-Kanal-Bilder (RGB), da das Netz RGB erwartet.
	* '''Visualisierung:''' Erstellt eine "Input ~~vs.~~ Output"~~-Collage~~.		* '''Rauschen:''' Über das Flag <code>isImageNoisy</code> wird gesteuert, ob das Bild bereits verrauscht ist. Falls nicht (0), fügt das Skript automatisch Gaußsches Rauschen hinzu.
			* '''Entrauschen:''' Das Bild wird durch das Netz geschickt (<code>denoiseImages</code>) und anschließend mittels <code>imresize</code> sicherheitshalber auf die Originalgröße zurückskaliert.
			* '''Fehlerbehandlung:''' Durch einen <code>try-catch</code>-Block stürzt das Skript nicht ab, falls eine einzelne Datei beschädigt ist.
			* '''Visualisierung:''' Erstellt eine Collage (Original \| Weißer Trennstrich \| Ergebnis) mit dynamischer Schriftgröße für die Beschriftung ("Input", "Output").

	== Code-Auszug ==		== Code-Auszug ==
	<syntaxhighlight lang="matlab">% Modell laden		<syntaxhighlight lang="matlab">
			clear; clc; close all;

			% --- Parameter ---
			imageFolder = './TestBilder'; % Verzeichnis mit den Testbildern
			isImageNoisy = 1; % 1 = Bilder sind schon verrauscht, 0 = Rauschen hinzufügen

			% --- Output Konfiguration ---
			outputFolder = fullfile(imageFolder, 'KI'); % Zielpfad
			if ~exist(outputFolder, 'dir')
			mkdir(outputFolder); % Erstellt Ordner, falls nicht vorhanden
			end

			% --- Modell laden ---
	if ~exist('net', 'var')		if ~exist('net', 'var')
	data = load(~~"Path~~/~~AI_InitialLearnRate_1e-3~~.mat");		% Lädt das trainierte Netzwerk (.mat Datei)
	net = data.net;		data = load('KIs/KI.mat');
			net = data.net;
	end		end

	% Rauschen ~~hinzufügen~~ (falls ~~nötig~~)		% --- Bilder suchen (Auszug) ---
	if ~isImageNoisy		% (Hier sucht das Skript nach .png, .jpg, .tif, etc. und füllt 'allImages')
	imgDouble = imnoise(imgDouble, "gaussian", 0, 0.03);		% ...
	end
			% --- Verarbeitungs-Schleife ---
			fprintf('Verarbeite %d Bilder. Bitte warten...\n', numel(allImages));

			for k = 1:numel(allImages)
			try
			% Bild laden und Basisnamen extrahieren
			fullFileName = fullfile(allImages(k).folder, allImages(k).name);
			[~, baseName, ~] = fileparts(allImages(k).name);

			imgDouble = im2double(imread(fullFileName));

			% Graustufen zu RGB konvertieren falls nötig
			if size(imgDouble, 3) == 1
			imgDouble = cat(3, imgDouble, imgDouble, imgDouble);
			end

			[h, w, ~] = size(imgDouble); % Original-Dimensionen speichern

			% Rauschen simulieren (falls Flag auf 0)
			if ~isImageNoisy
			imgDouble = imnoise(imgDouble, "gaussian", 0, 0.03);
			end

			% --- Entrauschen ---
			% Wendet das Netz an
			imgRestored = denoiseImages(net, imgDouble, 50, 20, true);

			% Auf Originalgröße zurückskalieren & RGB sicherstellen
			imgRestored = imresize(imgRestored, [h, w]);
			if size(imgRestored, 3) == 1
			imgRestored = cat(3, imgRestored, imgRestored, imgRestored);
			end

	% ~~Entrauschen~~		% --- Collage erstellen (Input \| Separator \| Output) ---
	~~imgRestored~~ = ~~denoiseImages~~(~~net~~, imgDouble, 50, ~~50/2, true)~~;		separatorWidth = 20;
			separator = ones(h, separatorWidth, 3); % Weißer Streifen
			collage = [imgDouble, separator, imgRestored];

	% ~~Collage erstellen (~~Input ~~\| Separator \|~~ Output)		% Beschriftung und Positionierung
	~~separatorWidth~~ = 20;		textLabels = {'Input', 'Output'};
	~~separator = ones~~(h, separatorWidth~~, 3~~);		positions = [10, 10; (w + separatorWidth + 10), 10];
	~~collage = [imgDouble, separator~~, ~~imgRestored~~];

	% ~~Beschriftung einfügen~~		collage = insertText(collage, positions, textLabels, ...
	~~textLabels = {~~'~~Input~~', '~~Output~~'};		'FontSize', max(20, round(h/25)), ... % Dynamische Schriftgröße
	~~positions = [10~~, ~~10; (w + separatorWidth + 10~~)~~, 10]~~;		'BoxColor', 'white', 'BoxOpacity', 0.7, 'TextColor', 'black');

	~~collage~~ = ~~insertText~~(~~collage~~, ~~positions, textLabels, ..~~.		% Speichern
	'~~FontSize', max(20, round(h/25)~~)~~, ...~~		saveName = fullfile(outputFolder, [baseName '_Result.jpg']);
	~~'BoxColor', 'white'~~, ~~...~~		imwrite(collage, saveName);
	~~'BoxOpacity', 0.7~~);

	~~imwrite~~(~~collage~~, ~~saveName~~);</syntaxhighlight>		catch ME
			% Fehler abfangen und Loop fortsetzen
			fprintf('Konnte %s nicht speichern: %s\n', allImages(k).name, ME.message);
			end
			end
			</syntaxhighlight>

	= Rausch-Generator Tool (<code>DnCNNNoise.m</code>) =		= Rausch-Generator Tool (<code>DnCNNNoise.m</code>) =

Adrian.klinspon@stud.hshl.de: /* Training (DnCnnTrain.m) */

2026-01-09T08:18:57Z

Training (DnCnnTrain.m)

Änderungen zeigen

Adrian.klinspon@stud.hshl.de: /* Funktionsweise */

2026-01-09T07:47:00Z

Funktionsweise

← Nächstältere Version		Version vom 9. Januar 2026, 07:47 Uhr
Zeile 13:		Zeile 13:

	== Funktionsweise ==		== Funktionsweise ==
	Das Skript prüft ~~zunächst~~, ob ~~bereits generierte Bild-~~Patches existieren und ~~fragt den Nutzer~~ via Dialog, ~~ob diese neu erstellt werden sollen~~ oder ob ein ~~bereits existierendes KI-Modell weiter trainiert werden soll~~.		Das Skript prüft, ob Patches existieren, und bietet via Dialog an, neue zu erstellen oder ein bestehendes Netz weiterzutrainieren.
	* '''Daten-Verarbeitung'''		* '''Daten-Verarbeitung'''
	** '''Quellen:''' Bilder werden aus <code>./ImagesForTraining</code> geladen.		** '''Quellen:''' Bilder werden aus <code>./ImagesForTraining</code> (und Unterordnern) geladen.
			** '''Patch-Extraktion:''' Bilder werden in 50x50 Pixel große Ausschnitte zerlegt (Stride: 30px, Overlap: 20px).
	** '''Filterung:''' Nur RGB-Bilder, die größer als die Patches sind, werden verarbeitet.		** '''Filterung:''' Nur RGB-Bilder, die größer als die Patches sind, werden verarbeitet.
	** '''Patch-Extraktion:''' Bilder werden in 50x50 Pixel große Quadrate zerlegt (Stride: 30px).
	** '''Speicherung:''' Patches werden physisch im Ordner <code>./PatchesCreatedByThisScriptInOrderToProperlyTrainTheAI</code> abgelegt.		** '''Speicherung:''' Patches werden physisch im Ordner <code>./PatchesCreatedByThisScriptInOrderToProperlyTrainTheAI</code> abgelegt.
	* '''Datensatz-Split:''' Die erstellten Patches werden im Verhältnis 90:10 in Trainings- und Validierungsdaten unterteilt (<code>trainSplit = 0.9</code>)		* '''Datensatz-Split:''' Die erstellten Patches werden im Verhältnis 90:10 in Trainings- und Validierungsdaten unterteilt (<code>trainSplit = 0.9</code>)

Adrian.klinspon@stud.hshl.de: /* Technische Voraussetzungen */

2026-01-06T14:41:22Z

Technische Voraussetzungen

← Nächstältere Version		Version vom 6. Januar 2026, 14:41 Uhr
Zeile 6:		Zeile 6:
	* Deep Learning Toolbox		* Deep Learning Toolbox
	* Image Processing Toolbox		* Image Processing Toolbox
			* Computer Vision Toolbox
	* Parallel Computing Toolbox		* Parallel Computing Toolbox

Adrian.klinspon@stud.hshl.de am 15. Dezember 2025 um 15:14 Uhr

2025-12-15T15:14:56Z

← Nächstältere Version		Version vom 15. Dezember 2025, 15:14 Uhr
Zeile 9:		Zeile 9:

	= Training (<code>DnCnnTrain.m</code>)=		= Training (<code>DnCnnTrain.m</code>)=
	Trainiert das neuronale Netz mit Bildern aus dem Ordner <code>./~~BSDS500~~</code>.		Trainiert das neuronale Netz mit Bildern aus dem Ordner <code>./ImagesForTraining</code>. Dieser Ordner enthält die Trainingsdaten, zusammengestellt aus den Datensätzen BSDS500 und DIV2K.

	== Funktionsweise ==		== Funktionsweise ==
	~~Im Gegensatz zu einfachen Ansätzen lädt dieses~~ Skript ~~nicht ganze Bilder~~, ~~sondern zerlegt diese in kleine Ausschnitte (~~Patches), ~~um den GPU~~-~~Speicher effizient zu nutzen und~~ die ~~Trainingsmenge zu erhöhen~~.		Das Skript prüft zunächst, ob bereits generierte Bild-Patches existieren und fragt den Nutzer via Dialog, ob diese neu erstellt werden sollen oder ob ein bereits existierendes KI-Modell weiter trainiert werden soll.
			* '''Daten-Verarbeitung'''
	* '''Patch-Extraktion:''' Bilder werden in 50x50 Pixel große Quadrate zerlegt (Stride: 30px).		** '''Quellen:''' Bilder werden aus <code>./ImagesForTraining</code> geladen.
	* '''Speicherung:''' Patches werden physisch im Ordner <code>./PatchesCreatedByThisScriptInOrderToProperlyTrainTheAI</code> abgelegt.		** '''Filterung:''' Nur RGB-Bilder, die größer als die Patches sind, werden verarbeitet.
	* '''Architektur:''' Ein 15-Layer tiefes CNN mit Residual Learning ~~(Regression Layer am Ende)~~.		** '''Patch-Extraktion:''' Bilder werden in 50x50 Pixel große Quadrate zerlegt (Stride: 30px).
			** '''Speicherung:''' Patches werden physisch im Ordner <code>./PatchesCreatedByThisScriptInOrderToProperlyTrainTheAI</code> abgelegt.
			* '''Datensatz-Split:''' Die erstellten Patches werden im Verhältnis 90:10 in Trainings- und Validierungsdaten unterteilt (<code>trainSplit = 0.9</code>)
			* '''Noise-Augmentation:''' Während des Trainings wird dynamisch Rauschen mittels einer Helper-Funktion (<code>addNoise</code>) hinzugefügt.
			* '''Architektur:''' Ein 15-Layer tiefes CNN mit Residual Learning.
	* '''Optimiser:''' Verwendet ADAM mit dynamischer Anpassung der Lernrate (Piecewise Drop).		* '''Optimiser:''' Verwendet ADAM mit dynamischer Anpassung der Lernrate (Piecewise Drop).
			* '''Training-Modi:''' Über einen Dialog kann gewählt werden zwischen:
			# '''Train new AI:''' Startet mit einer Lernrate von <code>1e-3</code>.
			# '''Train old AI:''' Lädt trainierte AI und setzt das Training mit einer feineren Lernrate von <code>1e-4</code> fort.

	== Code-Auszug ==		== Code-Auszug ==
	<syntaxhighlight lang="matlab">% ~~Konfiguration~~		<syntaxhighlight lang="matlab">% --- Pfade & Grundkonfiguration ---
	~~patchSize~~ = 50;		pathToImages = './ImagesForTraining';
	~~networkDepth~~ = 15;		patchDirectory = './PatchesCreatedByThisScriptInOrderToProperlyTrainTheAI';
	~~numFilters~~ = 64;		pathToSavedAI = './KIs/AI.mat';

	% GPU~~-Kompatibilität erzwingen~~		patchSize = 50;
			stride = 30;
			trainSplit = 0.9; % 90% Training, 10% Validierung
			maxPatchesPerImage = 1500;

			% GPU aktivieren
	parallel.gpu.enableCUDAForwardCompatibility(true);		parallel.gpu.enableCUDAForwardCompatibility(true);

	% ~~Netzwerk~~-~~Architektur (Auszug)~~		% --- Benutzer-Dialog 1: Patches erstellen? ---
	~~layers~~ = [		areNewPatchesNeeded = false;
	~~imageInputLayer([patchSize patchSize channels], "Normalization", "none")~~
	~~convolution2dLayer(3, numFilters, 'Padding', 'same')~~
	~~batchNormalizationLayer~~
	~~reluLayer~~
	];

	~~% Dynamischer Aufbau der mittleren Layer~~		if ~isempty(dir(fullfile(patchDirectory, '*.png')))
	~~for i = 2:~~(~~networkDepth-1~~)		recreatePatches = questdlg('Patches already Exist. Do you want do Delete them and Create new ones?', ...
	~~layers~~ = [		'Create new Patches?', 'Yes', 'No', 'Yes');
	~~layers~~
	~~convolution2dLayer(3~~, ~~numFilters~~, '~~Padding~~', '~~same~~')		if strcmp(recreatePatches, 'Yes')
	~~batchNormalizationLayer~~		areNewPatchesNeeded = true;
	~~reluLayer~~		delete(fullfile(patchDirectory, '*.png')); % Löscht alte Patches
	];		end
			else
			areNewPatchesNeeded = true;
	end		end

	% ~~Abschluss~~ (~~Residual Learning~~)		% (Hier folgt im Skript der Code zur Erstellung der Patches, falls areNewPatchesNeeded == true)
	~~layers = [~~
	~~layers~~		% --- Datastore & Split Logik ---
	~~convolution2dLayer~~(3, ~~channels~~, ~~"Padding","same"~~)		% Lädt alle Patches
	~~batchNormalizationLayer~~		allPatches = imageDatastore(patchDirectory, 'ReadFcn', @(f)im2double(imread(f)));
	~~regressionLayer~~
	];		% Zufällige Aufteilung in Training (90%) und Validierung (10%)
			numFiles = numel(allPatches.Files);
			idx = randperm(numFiles); % Erzeugt zufällige Indizes
			trainFiles = allPatches.Files(idx(1:round(trainSplit * numFiles)));
			valFiles = allPatches.Files(idx(round(trainSplit * numFiles) + 1:end));

			% Datastores mit Rauschen (addNoise Funktion)
			dsTrain = transform(imageDatastore(trainFiles), @(x)addNoise(x, useResidual));
			dsVal = transform(imageDatastore(valFiles), @(x)addNoise(x, useResidual));

	% Training ~~starten~~		% --- Benutzer-Dialog 2: Training Modus ---
			trainNewOrOldAI = questdlg('Would you like to...', 'Training Options', 'Train new AI', 'Train old AI', 'Train new AI');
			initialLRate = 1e-3; % Standard Lernrate

			if strcmp(trainNewOrOldAI, 'Train old AI')
			if exist(pathToSavedAI, 'file')
			loadNet = load(pathToSavedAI);
			lGraph = layerGraph(loadNet.net);
			initialLRate = 1e-4; % Feinere Lernrate für Nachtraining
			else
			trainNewOrOldAI = 'Train new AI'; % Fallback
			end
			end

			% --- Training Starten ---
	options = trainingOptions("adam", ...		options = trainingOptions("adam", ...
	'MaxEpochs', 70, ...		'MaxEpochs', 70, ...
	'~~ExecutionEnvironment~~', '~~gpu~~', ...		'MiniBatchSize', 128, ...
	);		'InitialLearnRate', initialLRate, ...
	net = trainNetwork(dsTrain, lgraph, options);</syntaxhighlight>		'LearnRateSchedule', 'piecewise', ...
			'ValidationData', dsVal, ...
			'CheckpointPath', './Checkpoints/LAB29-06', ...
			'OutputNetwork', 'best-validation-loss');

			net = trainNetwork(dsTrain, lgraph, options);
			save(pathToSavedAI, 'net');</syntaxhighlight>

	= Evaluierung (<code>DnCnnEval.m</code>) =		= Evaluierung (<code>DnCnnEval.m</code>) =