Nicos Garden

Neuronale Netze mit Python

3 min read

imports

import numpy as np
np.random.seed(42)
import tensorflow as tf
tf.random.set_seed(42)
from tensorflow import keras
from sklearn.model_selection import train_test_split
from keras.layers import Activation     #Import Modul für die Aktivierungsfunktion
from keras.layers import Dense          #Anzahl der Dichte der "Neuronen"
from keras.models import Sequential     #Modul zum Erzeugen des Neuronalen Netzes
from keras.optimizers import SGD        #Import Modul Stochastic Gradient Decent
from keras.utils import to_categorical  #Converts a class vector to binary class matrix.

Daten laden

dataset = load_digits()
x = dataset.data
y = dataset.target
 
y_cat=to_categorical(y,num_classes=10) #denke optional
 
x_train, x_test, y_train, y_test = train_test_split(x, y_cat, test_size=0.30)

Daten normalisieren

Normalisieren des Datasets

Man reduziert den Wertebereich behält dabei aber die Abstände (Relation/Korrelation) zwischen den Punkten bei. Alle Daten, die das Modell ab da verwendet müssen normalisiert sein (Training, Test, Prediction)

Die y-Daten dürfen nicht normalisiert werden!

Es gibt 2 Arten von Scalern:

Min Max Scaler

  • Wenn die Daten nicht als Normalverteilung vorliegen
  • Neuronale Netze funktionieren mit Min Max Scaler besser
from sklearn.preprocessing import MinMaxScaler
from sklearn.model_selection import train_test_split
 
scaler = MinMaxScaler()
scaler.fit(x)
x_transformed = scaler.transform(x)
x_train, x_test, y_train, y_test = train_test_split(x_transformed, y, test_size=0.3)

Standard Scaler

  • Ziel dass die Werte einen Mittelwert von 0 und eine Standardabweichung von 1 haben
  • Wenn die Daten normalverteilt sind oder einer Gaußschen Verteilung folgen Wobei der Mittelwert und die Standardabweichung ist.
from sklearn.preprocessing import StandardScaler 
 
scaler=StandardScaler()  
scaler.fit(x)
x_transformed=scaler.transform(x) 
x_train, x_test, y_train, y_test = train_test_split(x_transformed, y, test_size=0.3)
Link to original

Neuronales Netz bauen

from keras import layers
from tensorflow.keras.layers import Activation
from tensorflow.keras.layers import Dense
from tensorflow.keras.models import Sequential
from tensorflow.keras.optimizers import SGD
 
model = Sequential()
model.add(layers.Input(shape=(x.shape[1],),name='Eingabeschicht'))
model.add(Dense(units=450,name='Erste_verdeckte_Schicht'))           #Neuronen
model.add(Activation("relu",name='Aktivierungsfunktion_Schicht1'))   #Aktivierungsfunktion
model.add(Dense(units=450,name='Zweite_verdeckte_Schicht'))
model.add(Activation("relu",name='Aktivierungsfunktion_Schicht2'))
model.add(Dense(units=3,name='Ausgabeschicht'))
model.add(Activation("softmax",name='Aktivierungsfunktion_der_Ausgabeschicht'))

Modell anzeigen lassen

model.summary()

Model: “sequential”

┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓
┃ Layer (type)                    ┃ Output Shape           ┃       Param # ┃
┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩
│ Hidden_Layer1 (Dense)           │ (None, 512)            │        33,280 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ Aktivierungsfunktion_Hidden_La… │ (None, 512)            │             0 │
│ (Activation)                    │                        │               │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ Hidden_Layer2 (Dense)           │ (None, 256)            │       131,328 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ Aktivierungsfunktion_Hidden_La… │ (None, 256)            │             0 │
│ (Activation)                    │                        │               │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ Hidden_Layer3 (Dense)           │ (None, 128)            │        32,896 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ Aktivierungsfunktion_Hidden_La… │ (None, 128)            │             0 │
│ (Activation)                    │                        │               │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ dense (Dense)                   │ (None, 10)             │         1,290 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ activation (Activation)         │ (None, 10)             │             0 │
└─────────────────────────────────┴────────────────────────┴───────────────┘

Total params: 198,794 (776.54 KB) Trainable params: 198,794 (776.54 KB) Non-trainable params: 0 (0.00 B)

Model kompilieren

  • eine Fehlerfunktion: hier categorical_crossentropy
  • eine Optimierung: hier SDG
  • und eine an zu wendende Metrik: hier accuracy
model.compile(
	loss="categorical_crossentropy", optimizer=SGD(), metrics=["accuracy"]
)

Model trainieren

model.fit(x=x_train, y=y_train, epochs=30, validation_data=(x_test,y_test))

Speichern und Laden

import keras
model.save("NeuronalesNetz.kaeras")
loaded_model = keras.models.load_model("NeuronalesNetz.kaeras")

Weitere Schichten

Convolutional Neural Networks (CNNs)

  • Conv1D, Conv2D, Conv3D: Faltungsschichten für 1D, 2D oder 3D Daten
  • SeperableConv2D: Effizientere Variante der 2D-Faltung
  • DepthwiseConv2D: Faltung über räumliche Dimensionen
  • Conv2DTranspose: Transponierte Faltung (für Upsampling)
import keras
model.add(keras.layers.Conv2D(filters=32, kernel_size=(3,33)))

Pooling Layers

  • MaxPooling1D, MaxPooling2D, MaxPooling3D: Maximales pooling
  • AveragePooling1D, AveragePooling2D, AveragePooling3D: Durchschnittliches Pooling
  • GlobalMaxPooling2D, GlobalAveragePooling2D: Globales Pooling über gesamte Feature Maps.
import keras
model.add(keras.layers.MaxPooling2D(pool_size=(22, 2)))

Recurrent Layers

  • Simple RNN: Einfache rekurrente Schicht
  • LSTM: Long Short-Term Memory
  • GRU: Gated Recurrent Unit
  • Bidirectional: Wrapper für bidirektionale RNNs
  • ConvLSTM2D: Kombination aus CNN und LSTM
import keras
model.add(keras.layers.LSTM(128))

Normalization Layers

  • Batch Normalization: Normalisiert Aktivierungen über Batch
  • Layer Normalization: Normalisiert über Features
  • Group Normalization: Normalisiert Gruppen von Kanälen
  • Unit Normalization: Normalisiert auf Einheitslänge
import keras
model.add(keras.layers.Normalization(axis=-1, mean=None, variance=None, invert=False))

Regularization Layers

  • Dropout: Zufälliges Deaktivieren von Neuronen
  • SpatialDropout1D/2D/3D: Dropout ganzer Feature-Maps
  • GaussianDropout: Dropout mit Gaußschem Rauschen
  • GaussianNoise: Fügt Gaußsches Rauschen hinzu
  • AlphaDropout: Spezielles Dropout für SELU-Aktivierung
import keras
model.add(keras.layers.Dropout(rate=0.25))

Reshaping Layers

  • Flatten: Flacht mehrdimensionale Eingaben ab
  • Reshape: Ändert die Form der Daten
  • Permute: Vertauscht Dimensionen
  • RepeatVector: Wiederholt Eingabe n-mal
  • Cropping1D/2D/3D: Schneidet Dimensionen zu
  • UpSampling1D/2D/3D: Vergrößert räumliche Dimensionen
  • ZeroPadding1D/2D/3D: Fügt Nullen hinzu
import keras
model.add(keras.layers.Flatten())

Merging Layers

  • Concatenate: Verbindet Tensoren entlang einer Achse
  • Add: Addiert mehrere Tensoren
  • Subtract: Subtrahiert Tensoren
  • Multiply: Multipliziert Tensoren elementweise
  • Average: Berechnet Durchschnitt mehrerer Tensoren
  • Maximum/Minimum: Elementweises Maximum/Minimum
  • Dot: Skalarprodukt
import keras
tf_keras.layers.Concatenate(axis=-1)

Embedding Layers

  • Embedding: Wandelt Integer-Indizes in dichte Vektoren um
  • TextVectorization: Vektorisiert Text (Preprocessing)
import keras
model.add(keras.layers.Embedding(input_dim=1000, output_dim=64))

Graph View