Mathesis Wiki

Dies ist eine alte Version des Dokuments!

---

<code>

from example_physionet import X, Y # Daten importieren

import torch import torch.nn as nn import torch.nn.functional as F from torch.autograd import Variable import torch.optim as optim

import random import numpy as np import pandas

y_train = Y['diagnostic_superclass'][:1000] XY = [(X[i],y_train[i+1]) for i in range(1000)]

y_test = Y['diagnostic_superclass'][1101:1201] x_test = X[1100:1200]

class Netzwerk(nn.Module):

  def __init__(self):
      super(Netzwerk, self).__init__()
      self.conv1 = nn.Conv1d(12, 12, kernel_size=3, stride=1, padding=1)
      self.pool1 = nn.MaxPool1d(kernel_size=3, stride=2, padding=1)
      self.conv2 = nn.Conv1d(12, 4, kernel_size=2, padding=1)
      self.pool2 = nn.MaxPool1d(3, stride=2, padding=0)
      self.lin1 = nn.Linear(4*250, 30)
      self.lin2 = nn.Linear(30, 10)
      self.lin3 = nn.Linear(10, 2)

  def forward(self, x):
      x = self.pool1(F.relu(self.conv1(x)))
      x = self.pool2(F.relu(self.conv2(x)))
      x = x.view(-1, 4*250)       # umwandeln der Shape, sodass Uebergang von Conv. Layer zu linearen layers moeglich
      x = F.relu(self.lin1(x))
      x = F.relu(self.lin2(x))
      x = self.lin3(x)
      return x

  def num_flat_features(self, x):
    """eigentlich irrelevant???"""
    size = x.size()[1:]
    num = 1
    for i in size:
      num *= i
    return num

net = Netzwerk() learning_rate = 0.1 batch_size = 40 optimizer = optim.SGD(net.parameters(), lr=learning_rate)

def is_norm(y):

  """wandelt Label des Datensatzes aus Textform in fuer Netzwerk erkennbare Form um"""
  if y == ['NORM']:        # Y-Index ist im Vergleich zum X-Index um +1 verschoben
      return [1, 0]
  else:
      return [0, 1]

def train(epoch = 50, b_s = batch_size):

  net.train()
  for i in range(epoch):
      random.shuffle(XY)

      # input-Werte
      my_inp = [XY[j][0].T for j in range(batch_size)]
      my_in = Variable(torch.Tensor(my_inp))
      my_in = my_in.reshape(batch_size, 12, 1000)

      # target-Werte
      ziel = [is_norm(XY[k][1]) for k in range(batch_size)]
      zielw = Variable(torch.Tensor(ziel))
      zielw = zielw.unsqueeze(1)

      criterion = nn.MSELoss()    # die Fehlerfunktion auf mean-squared-error setzen
      optimizer.zero_grad()       # Gradienten der vorherigen Epoche ausloeschen
      out = net(my_in)            # forward propagation

      loss = criterion(out, zielw)    # Fehler berechnen
      loss.backward()                 # backward propagation
      optimizer.step()                # weights and biases neu einstellen
      print(evaluate())               # Evaluation mit unabhaengigen Test-Daten printen

def evaluate(welche_richtig=False):

  """ermittelt, wie oft das Netz ein richtig zugeordnetes EKG erkennt
  mittels 'welche_richtig=True' kann man sich die Label der richtig erkannten EKGs ausgeben lassen"""
  global y_test
  global x_test
  z = 0
  for i in range(100):
      x = Variable(torch.Tensor(x_test[i]))
      x = x.reshape(12, 1000)
      x = x.unsqueeze(0)
      #x = x.unsqueeze(0)
      if torch.argmax(net(x)) == np.argmax(is_norm(y_test[1102+i])):
          z += 1
          if welche_richtig==True:        # printet Labels der richtig klassifizierten EKGs aus Test-Werten
              print(y_test[1102+i])
  return z

train()