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 ====
In der Trainingsfunktion werden zunächst die Input- und Ziel-Werte entsprechend der Batch-Size eingelesen, sodass sie dem Netzwerk übergeben werden können. Anschließend werden die Input-Werte vorwärts durch das Netz geschickt //(forward propagation)// und die Differenz der Ergebnisse mit den Zielwerten verglichen //(Fehler berechnen)//. Daraufhin wird dieser rückwarts durch das Netz zurück geschickt //(backward propagation)//, wobei die Neujustierung der Gewichte im Netzwerk berechnet wird. All dies passiert innerhalb einer //for-Schleife//, welche dafür sorgt, dass die Anpassung der Parameter, entsprechend der Epochen-Anzahl, wiederholt wird.
<code>
def train(epoch = 3000, b_s = batch_size):
    net.train()
    for i in range(epoch):
        random_batch = [np.random.randint(len(X_train)) for i in range(b_s)]

        # input-Werte
        my_in = np.swapaxes(X_train[random_batch], 1, 2)
        my_in = Variable(torch.Tensor(my_in))
        my_in.unsqueeze(2)

        # target-Werte
        ziel = y_train[y_train.index[random_batch]].tolist()
        zielw = Variable(torch.Tensor(ziel))
        zielw = zielw.type(torch.LongTensor)
        
        # forward propagation
        criterion = nn.CrossEntropyLoss()  
        optimizer.zero_grad()               
        out = net(my_in)                     

        # Fehler berechnen
        loss = criterion(out, zielw)         

        #backward propagation
        loss.backward()                       
        optimizer.step()                     
        net.history_loss.append(loss)
</code>
==== Evaluationsfunktion ====
Die Evaluationsfunktion dient der Überprüfung des Lernprozesses und -erfolges. Wir übergen ihr unabhängige Testdaten, die das Netzwerk während des Trainings noch nicht gesehen hat und schicken diese durch unser Netzwerk. Anschließend ermitteln wir, wie viele der Testdaten von dem trainierten Netz richtig erkannt wurden.

<code>
def evaluate(test_x = X_evaluation, test_y = y_evaluation):
    net.eval()
    z = 0
    for i in range(len(test_x)):
        x = np.swapaxes(test_x[i], 0, 1)
        x = Variable(torch.Tensor(x))
        x = x.unsqueeze(0)
        if torch.argmax(net(x)) == test_y[test_y.index[i]]:
            z += 1
    return z/len(test_x)
</code>
==== Ergebnis ====
{{ws2021:ekg:cross_entropy_loss2.png }} 
Der Graph zeigt die Klassifizierungsgenauigkeit //(blau)// und den Fehler //(orange)// über 9.000 Epochen. Unser Netz erkennt also ungefähr 83% der unabhängigen Test-Daten richtig. Das ist insofern ein Erfolg, dass ohne Training nur in etwa die Hälfte der EKGs richtig zugeordnet werden, da circa eine Hälfte der Daten jeweils gesunde beziehungsweise ungesunde EKGs enthalten. Somit hat unser Netz erfolgreich gelernt!


Allerdings ist dies noch ausbaufähig, da in etwa jedes fünfte EKG falsch zugeordnet wird. Für eine Anwendung in der klinischen Praxis ist die Fehlerquote demnach viel zu hoch und der Algorithmus nicht zuverlässig. Dennoch ist es für uns, mit sehr wenig Programmier-Erfahrung, für ein Erst-Semester Projekt ein großer Erfolg.
===== 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 ======

====Grundlagen Machine Learning ====

[[http://neuralnetworksanddeeplearning.com/index.html|'neural networks and deep learning' book - Michael Nielsen]]

[[https://www.youtube.com/playlist?list=PLZHQObOWTQDNU6R1_67000Dx_ZCJB-3pi | artificial intelligence video series - 3Blue1Brown]]

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

====Datensatz====
[[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://github.com/helme/ecg_ptbxl_benchmarking/blob/c1efb0275c0d278e5a09d5e9dbbbb85fad629ce3/code/models/resnet1d.py#L90|ResNet implementation for PTB-XL ecg dataset - GitHub]]

====Implementation unseres Netzes====

=== Pytorch===
[[https://towardsdatascience.com/pytorch-basics-how-to-train-your-neural-net-intro-to-cnn-26a14c2ea29| pytorch basics: how to train a neural net into cnn - Towards Data Science]]

[[https://www.analyticsvidhya.com/blog/2019/09/introduction-to-pytorch-from-scratch/?utm_source=blog&utm_medium=building-image-classification-models-cnn-pytorch| a beginner friendly guide to PyTorch and how it works from scratch]]

[[https://pytorch.org/tutorials/beginner/deep_learning_60min_blitz.html|Deep Learning with PyTorch: A 60 Minute Blitz]]

[[https://towardsdatascience.com/how-to-build-your-own-neural-network-from-scratch-in-python-68998a08e4f6|How to build your own Neural Network from scratch in Python - Towards Data Science]]

===Verbesserung des Netzes===

[[https://medium.com/@Rehan_Sayyad/how-to-use-convolutional-neural-networks-for-time-series-classification-80575131a474|How to Use Convolutional Neural Networks for Time Series Classification]]

[[https://towardsdatascience.com/a-comprehensive-guide-to-convolutional-neural-networks-the-eli5-way-3bd2b1164a53|A Comprehensive Guide to Convolutional Neural Networks — the ELI5 way]]

[[https://machinelearningmastery.com/convolutional-layers-for-deep-learning-neural-networks/|How Do Convolutional Layers Work in Deep Learning Neural Networks?]]

[[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 | ResNet implementation - Towards Data Science]]

[[https://towardsdatascience.com/an-overview-of-resnet-and-its-variants-5281e2f56035|an overview of ResNet and its variants - Towards Data Science]]

[[https://towardsdatascience.com/batch-normalization-an-intuitive-explanation-42e473fa753f| Batch-Normalization - Towards Data Science]]
Mathesis Wiki

Benutzer-Werkzeuge

Webseiten-Werkzeuge

Seiten-Werkzeuge
