Mathesis Wiki

Diese Seite ist nicht editierbar. Sie können den Quelltext sehen, jedoch nicht verändern. Kontaktieren Sie den Administrator, wenn Sie glauben, dass hier ein Fehler vorliegt.
======= EKG-Analyse =======

====== Teilnehmer ======
Elena, Annika

====== Projektidee und Ziele ======
Unser grundsätzliches Ziel ist es, EKG-Daten auszuwerten und diese, mithilfe eines Algorithmus, nach krank und gesund zu unterscheiden. Da das Analysieren eines solchen EKGs eine für den Menschen sehr komplexe Aufgabe ist, wollten wir herausfinden, ob es einfacher ist, diese Problemstellung von einem Computer lösen zu lassen.
===== Zwischenziele und Zeitplan =====
[[hier kommt ihr zu unseren genauen Zwischenzielen und unserem Zeitplan]]

====== Dokumentation ======
===== Einführung =====
==== Medizinische Grundlagen ====

== Was ist ein EKG? ==
Ein **E**lektro**k**ardio**g**ramm ist ein weit verbreitetes Diagnoseverfahren, welches Medizinern Aufschlüsse über die Gesundheit des Herzens eines Patienten liefert. Es ist eine nicht-invasive Methode, die für Patienten kaum Risiken birgt, weshalb sie in der Praxis standardmäßig eingesetzt wird.


== Wie und was misst ein EKG? ==
Ein Elektrokardiogramm misst die elektrische Erregung im Herzen, indem 10 Elektroden den Strom an der Hautoberfläche detektieren. Diese werden im Anschluss so miteinander verschaltet, dass 12 Spannungskurven entstehen, aus denen dann Rückschlüsse auf die Pumpaktivität des Herzens und somit die kardiologische Gesundheit eines Menschen gezogen werden können. 

{{ws2021:ekg:schem_ekg_beschriftet.png?390|schematische Darstellung Sinuskurve}}
{{ws2021:ekg: echtes_ekg_annotiert2.png?250|Sinuskurve aus Datensatz}}

Hier seht ihr einen gesunden Sinusrhythmus (schematisch und ein Plot aus dem Datensatz), wie genau er aufgebaut ist könnt ihr [[hier]] erfahren.

==== Datensatz ====
Die Daten, die wir analysiert haben, stammen aus einem riesigen öffentlichen Datensatz im Internet, der Daten von 18.885 Patienten umfasst. Das Besondere an diesem Datensatz ist, dass auch sehr viele kardiologisch gesunde Patienten inbegriffen sind. Oft wird das vernachlässigt, ist für uns aber besonders entscheidend, da wir ja einen Algorithmus kreieren wollen, der auch gesunde EKGs erkennt. Der Datensatz ist relativ neu und stammt von 2020. Er enthält Angaben zu den Patienten (sogenannte Metadaten), ein diagnostisches Label, wobei der Datensatz fünf Ober- und 24 Unterklassen unterscheidet, und die EKG-Messdaten. An den Datensatz anknüpfend wurde auch ein [[Python-Code]] zur Verfügung gestellt, mithilfe dessen, auf die Daten zugegriffen werden kann und, der die Daten schon in Trainings- und Testdaten unterteilt. 

[[ https://doi.org/10.13026/x4td-x982 | Hier geht es zum Datensatz]]

==== Machine Learning ====

==EKG-Analyse - Wie lassen sich Daten allgemein analysieren?==
Mithilfe von mathematischer Funktionen lassen sich allgemeine Informationen aus Daten ableiten. Bei dieser Art von Daten ist der Zusammenhang recht offensichtlich. Doch EKGs sind weitaus komplexere Datenstrukturen, dementsprechend komplex gestaltet sich auch unsere mathematische Analyse der Daten. Um Zusammenhänge zwischen solch komplexen Daten zu ermitteln, bietet sich Machine Learning an.

==Was ist Machine Learning?==
Maschinelles Lernen ist das näherungsweise Optimieren einer Funktion. Diese Funktion ordnet, mittels eines neuronalen Netzes, einem komplexen Input einen vorgegebenen Output zu. Dies bedeutet im Grunde, dass neuronale Netze einen mathematischen Weg nutzen, um allgemeine Merkmale aus Daten zu abstrahieren, die sich zum Beispiel mittels objektiver Labels verifizieren lassen. Da das Finden dieser mathematischen Funktion näherungsweise und Schritt für Schritt passiert, und an unserem menschlichen Lernen orientiert ist, spricht man von maschinellem Lernen.

==Was sind neuronale Netze?==
Neuronale Netze sind von den neuronalen Verknüpfungen unserer Gehirne inspirierte Strukturen. So bestehen sie aus mehreren Schichten aus Neuronen bzw. Knotenpunkten, die zunächst keinen eigenen Wert besitzen. Zwischen den Neuronen der Schichten gibt es Verbindungen und zwar von jedem Neuron der vorhergehenden Schicht zu jedem Neuron der darauffolgenden Schicht. Diese Verbindungen sind essentieller Bestandteil des Netzes. Denn jede Verbindung hat eine Gewichtung, die bestimmt, wie relevant die Verknüpfung zwischen den beiden Neuronen ist.

{{ws2021:ekg:nn_schematisch.jpeg|Schematische Darstellung eines neuronalen Netzes mit linearen Schichten und gewichteten Verbindungen}}

[[Wie das Netz lernt erfahrt ihr hier]]

==== Hilfsmittel und Bibliotheken ====
=== PyTorch ===
Für unser Netzwerk haben wir mit //Pytorch// gearbeitet. Das ist eine Python-Bibliothek, die viele Bausteine für die Implementierung neuronaler Netze enthält. Es vereinfacht vor allem den mathematisch-rechnerischen Teil und erleichtert es den Benutzern, eine Netzwerk-Architektur mit Schichten und Hyperparametern zu erstellen. 

=== Google Colab ===
Des Weiteren haben wir //Google CoLab// verwendet, eine Online-Programmierumgebung, die auf Jupyter-Notebooks basiert. Google stellt dort Server, also Rechenkapazität, zur Verfügung, was für neuronale Netze von großer Bedeutung ist, da diese sehr viel Speicher und Rechenleistung benötigen. Dabei haben wir mit CUDA gearbeitet, einer Technologie, mithilfe derer Teile des Codes auf einer Grafikkarte (GPU) ausgeführt werden können. 

===== Entwicklung unseres Netzwerkes =====
==== Netzwerkarchitektur ====

=== Lineare Layers ===
Zuerst haben wir eine Netzwerk-Klasse, bestehend aus //_init_-Konstruktor// und //forward-Funktion//, mithilfe der Pytorch-Bibliothek implementiert. Dabei enthält der //_init_-Konstruktor// die Definition für die Schichten im Netz. In der //forward-Funktion// werden dann die Verknüpfungen zwischen diesen Schichten hergestellt, in unserem Fall mittels der ReLu-Aktivierungsfunktion. Zunächst haben wir nur linearen Schichten gebaut, allerdings konnten wir damit keinen Lernerfolg erzielen, da jeglicher räumlicher Zusammenhang der Datenpunkte verloren geht.

<code>
class Netzwerk(nn.Module):
    def __init__(self):
        self.lin1 = nn.Linear(12*61, 800)
        self.lin2 = nn.Linear(800, 40)
        self.lin3 = nn.Linear(40, 10)
        self.lin4 = nn.Linear(10, 2)
        
    def forward(self, x):      
        x = F.relu(self.lin1(x))
        x = F.relu(self.lin2(x))
        x = F.relu(self.lin3(x))
        x = self.lin4(x)
        return x
</code>



=== Convolutional Layer ===
Deshalb sind wir zu einer Architektur mit gefalteten Schichten (//Convolutional Layern//) übergegangen. Dabei läuft ein Filter (//Kernel//) über das Bild, der einen bestimmten Ausschnitt der Daten zusammenfasst, bevor diese den linearen Schichten übergeben werden. Dies war für unser Netz essentiell, da so nicht alle Datenpunkte individuell betrachtet werden, sondern die einzelnen Datenpunkte in ihrem räumlichen Zusammenhang erkannt werden. Mithilfe der Convolutional Layers konnten wir unseren ersten Lernerfolg erzielen. 


[[Hier geht es zu unserem Code mit Convolutional Layern]].
=== ResNet-Archithektur ===
Im Anschluss haben wir eine ResNet-Architektur eingeführt, um einen besseren Lernerfolg durch ein tieferes Lernen zu erreichen. Bei der ResNet-Architektur werden noch zusätzliche Layer eingeführt, sogenannte Skip Connections, die immer ein paar Schichten überspringen und so einer späteren Schicht einen output von einer vorherigen Schicht geben. Dies ermöglicht mehr Schichten, ohne dass Informationen verloren gehen.
Wir haben für die Implementierung die Netzwerk-Klasse minimal verändert ([[zur aktualisierten Klasse kommt ihr hier]]) und eine [[zusätzliche Klasse Resnet]].

==== Netzwerkparameter ====
Im folgenden erzeugen wir ein Objekt der Netzwerk-Klasse: unser Netz, dass wir mit den EKG-Daten trainieren wollen. Außerdem definieren wir den //optimizer//, also die Art und Weise, wie die Gewichte im Netz  optimiert werden sollen, sodass das Netz EKGs erkennt. Dafür benutzen wir den SGD //(=stochastic Gradient Descent)// optimizer aus der Pytorch-Bibliothek. Diesem übergeben wir eine //learning_rate//, die die Schrittweite entlang des Gradienten bestimmt. Auch die //batch_size//, also die Anzahl an Trainings-Daten, über die gemittelt der Gradient berechnet wird, legen wir im folgenden Code fest.
<code>
net = Netzwerk()
learning_rate = 0.3
batch_size = 50
optimizer = optim.SGD(net.parameters(), lr=learning_rate)
</code>
==== Trainingsfunktion ====

==== Evaluationsfunktion ====

==== Ergebnis ====

===== Verlauf der Projektarbeit =====
==== Protokolle ====

[[Hier geht es zu den ausführlichen Protokollen]]

===== Fazit und Ausblick =====
Wir haben beide Python-Kenntnisse und medizinisches Wissen erworben und Erfahrungen im Bereich Machine Learning sammeln können. Fehlerbehebung mussten wir vor allem vornehmen, wenn es darum ging, dass bestimmte Tensor-Größen nicht zusammenpassten oder in- und output sich in ihrer Dimension unterschieden.
Man könnte das Netz mit Sicherheit noch weiter verbessern, indem man die Hyperparameter optimal einstellt und die Netzwerkarchitektur noch ein wenig anpasst. Außerdem könnte man als Erweiterung, das Netz spezifische Krankheitsbilder erkennen lassen. Dazu sind wir aus zeitlichen Gründen leider nicht mehr gekommen.

====== Literatur ======
[[https://doi.org/10.1038/s41597-020-0495-6 | Wagner, P., Strodthoff, N., Bousseljot, R.-D., Kreiseler, D., Lunze, F.I., Samek, W., Schaeffter, T. (2020), PTB-XL: A Large Publicly Available ECG Dataset. Scientific Data.]] 


[[https://www.youtube.com/playlist?list=PLZHQObOWTQDNU6R1_67000Dx_ZCJB-3pi | Videos zu Machine-Learning von 3Blue1Brown]]

[[https://www.timeseriesclassification.com/ | Time-Series classification]]

[[https://arxiv.org/pdf/1512.03385.pdf | Paper zu ResNet-Archithektur]]

[[https://www.youtube.com/watch?v=DkNIBBBvcPs | Video zu ResNet]]

[[https://github.com/helme/ecg_ptbxl_benchmarking/blob/c1efb0275c0d278e5a09d5e9dbbbb85fad629ce3/code/models/resnet1d.py#L90 | Beispielcode mit ResNet und PyTorch]]

[[https://towardsdatascience.com/residual-network-implementing-resnet-a7da63c7b278 | Artikel zu ResNet ]]
Mathesis Wiki

Benutzer-Werkzeuge

Webseiten-Werkzeuge

Seiten-Werkzeuge
