Nicos Garden

Neuronale Netze mit Python

2 min read

imports

import numpy as np
np.random.seed(42)
import tensorflow as tf
tf.random.set_seed(42)  #Auch in Tensorflow können wir einen Beginn
                        #für die Zufallszahlen festlegen
from tensorflow import keras
from sklearn.datasets import load_digits    #Import Dataset
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
  
print(y)
y_cat=to_categorical(y,num_classes=10)
print(y)
  
x_train, x_test, y_train, y_test = train_test_split(x, y_cat, test_size=0.30)

Neuronales Netz bauen

from keras.layers import Input
model=Sequential()
  
model.add(Input(shape=(x.shape[1],)))               #Eingabeschicht
model.add(Dense(units=512, name='Hidden_Layer1'))
model.add(Activation("relu", name='Aktivierungsfunktion_Hidden_Layer1'))
model.add(Dense(units=256, name='Hidden_Layer2'))
model.add(Activation("relu", name='Aktivierungsfunktion_Hidden_Layer2'))
model.add(Dense(units=128, name='Hidden_Layer3'))
model.add(Activation("relu", name='Aktivierungsfunktion_Hidden_Layer3'))
model.add(Dense(units=10))                          #Ausgabeschicht
model.add(Activation("softmax"))

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 compilieren

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))

Graph View