<jupyter_start><jupyter_text>0. Installieren aller Pakete<jupyter_code># Hier die Kaggle Credentials einfügen (ohne Anführungszeichen)

%env KAGGLE_USERNAME=openhpi
%env KAGGLE_KEY=das_ist_der_key
import warnings
warnings.filterwarnings('ignore')


import os
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3'
import matplotlib.pyplot as plt
import seaborn as sns
import keras

from keras.utils.vis_utils import plot_model

from keras.models import Sequential
from keras.layers import Dense, Conv2D , MaxPool2D , Flatten , Dropout , BatchNormalization
from keras.preprocessing.image import ImageDataGenerator
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import LabelBinarizer
from sklearn.metrics import classification_report,confusion_matrix

warnings.simplefilter('always', category=UserWarning)
import pandas as pd
import numpy as np
from matplotlib import rcParams
import string
rcParams['figure.figsize'] = 14, 10
def show_accuracy_loss_plot(history, num_epochs):
    epochs = [i for i in range(num_epochs)]
    fig , ax = plt.subplots(1,2)
    train_acc = history.history['accuracy']
    train_loss = history.history['loss']
    val_acc = history.history['val_accuracy']
    val_loss = history.history['val_loss']
    fig.set_size_inches(16,9)
    
    ax[0].plot(epochs , train_acc , 'go-' , label = 'Train Accuracy')
    ax[0].plot(epochs , val_acc , 'ro-' , label = 'Test Accuracy')
    ax[0].set_title('Training & Test Accuracy')
    ax[0].legend()
    ax[0].set_xlabel("Epochs")
    ax[0].set_ylabel("Accuracy")
    
    ax[1].plot(epochs , train_loss , 'g-o' , label = 'Training Loss')
    ax[1].plot(epochs , val_loss , 'r-o' , label = 'Testing Loss')
    ax[1].set_title('Training & Test Loss')
    ax[1].legend()
    ax[1].set_xlabel("Epochs")
    ax[1].set_ylabel("Loss")
    plt.show()<jupyter_output><empty_output><jupyter_text>4.5 Bilderkennung 1  Datensatz:  Sign Language MNIST DatasetÜber 34.000 Bilder zu Gebärdensprache und dazugehörige Übersetzung der Gesten in das Alphabet in A bis Z. Bilder in 28x28 Pixeln in Graustufen. Quelle: kaggle.com  Download Dataset   Manuellvia https://www.kaggle.com/datamunge/sign-language-mnist  Via APIHinzufügen der kaggle.jsonSpeichern als ~/.kaggle/kaggle.json auf Linux, OSX, oder anderen UNIX-basierten Betriebssystemen und unter C:\Users.kaggle\kaggle.json auf WindowsSiehe https://www.kaggle.com/docs/api oder https://github.com/Kaggle/kaggle-api        Beispiel:~/kaggle/kaggle.json{"username":"openHPI","key":"das_ist_der_key"}<jupyter_code>!pip3 install kaggle
!kaggle datasets download -d datamunge/sign-language-mnist
import zipfile
with zipfile.ZipFile("sign-language-mnist.zip", 'r') as zip_ref:
    zip_ref.extractall("")<jupyter_output><empty_output><jupyter_text>Was wir erreichen wollenZiel dieser Einheit ist es, Bilder von amerikanischer Gebärdensprache in das Alphabet von A bis Z zu übersetzen. Hierbei haben wir einen Trainings-Datensatz mit Labels für die verschiedenen Bilder.   Einlesen der Daten<jupyter_code>df_train = pd.read_csv("sign_mnist_train.csv")
df_test = pd.read_csv("sign_mnist_test.csv")<jupyter_output><empty_output><jupyter_text>Nachdem wir die Dateien eingelesen haben, speichern wir jeweils die Labels in eigenen Variablen und entfernen sie vom ursprünglichen Datensatz.<jupyter_code>y_test = df_test["label"]
y_train = df_train["label"]
del df_train['label']
del df_test['label']<jupyter_output><empty_output><jupyter_text>Wir normalisieren zunächst alle Pixel-Werte für die Bilder und konvertieren die einzelnen Pixel-Reihen zu 3D Bildern. Die dritte Dimension hier ist der Farbwert (hier nur eine Graustufe).<jupyter_code># Normalisierung
X_train = df_train.values/255
X_test = df_test.values/255

# Reshaping von 1D zu 3D
X_train = X_train.reshape(-1,28,28,1)
X_test = X_test.reshape(-1,28,28,1)<jupyter_output><empty_output><jupyter_text>Anschließend erstellen wir erneut eine Liste mit den verschiedenen Buchstaben, in die wir die einzelnen Bilder übersetzen wollen. Im Datensatz sind nur Nummern gegeben, aber mit dieser Liste können wir die jeweilige Nummer zu ihrem Buchstaben übersetzen.<jupyter_code>alphabetic_label = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z"]<jupyter_output><empty_output><jupyter_text>Label EncodingDie Labels wollen wir allerdings noch mit einem One-Hot-Encoder verarbeiten. Für jedes Label wird eine eigene Spalte eingeführt und nur eine "1" eingefügt, wenn ein Bild diesem Label angehört.<jupyter_code>lb=LabelBinarizer()
lb.fit(y_train)
y_test_oh = lb.transform(y_test)
y_train_oh = lb.transform(y_train)
# Ursprüngliches Label
y_train[0]
# Label nach One-Hot-Encoding
y_train_oh[0]<jupyter_output><empty_output><jupyter_text>Einfaches ModellWir definieren zunächst ein einfaches Convolutional Neural Network mit einem Convoluational Layer, einem Pooling Layer und einem Dense Layer (Fully-Connected Layer) vor dem Output-Layer. Damit wir etwas genauer verstehen, wie dieses Modell aufgebaut ist, so geben wir uns anschließend die Form des Modelles einmal graphisch aus. Wir sehen hier den Aufbau des Modells sowie die Anzahl der Parameter, die trainiert werden.<jupyter_code>model=Sequential()
model.add(Conv2D(128,kernel_size=(5,5),
                 strides=1,padding='same',activation='relu',input_shape=(28,28,1)))
model.add(MaxPool2D(pool_size=(3,3),strides=2,padding='same'))         
model.add(Flatten())

model.add(Dense(units=256,activation='relu'))
model.add(Dropout(rate=0.3))
model.add(Dense(units=24,activation='softmax'))
model.summary()

model.compile(optimizer='adam',loss='categorical_crossentropy',metrics=['accuracy'])
plot_model(model, show_shapes=True, show_layer_names=True)<jupyter_output><empty_output><jupyter_text>Zwar haben wir jetzt das Modell definiert, allerdings haben wir noch nichts trainiert. Das wollen wir im nächsten Schritt machen. Wir trainieren für 20 Epochen (also 20 Läufe durch den Datensatz). Im Laufe des Trainings speichern wir uns jeweils die Performance auf den Trainings- und Testdaten, um diese anschließend in einem Chart ausgeben zu können.<jupyter_code>history = model.fit(X_train,y_train_oh,
         epochs = 20,
          shuffle=1,
           validation_data=(X_test,y_test_oh),
         )<jupyter_output><empty_output><jupyter_text>Wir wollen uns nun einmal unser Training über die Zeit ansehen. Wie wir sehen, erreichen wir eine Accuracy von circa 92%. Optimal ist das noch nicht, aber durchaus ein sehr guter Anfang. Im Folgenden wollen wir noch einmal sehen, ob wir mit einem komplexeren Modell bessere Ergebnisse erzielen.<jupyter_code>show_accuracy_loss_plot(history, num_epochs=20)<jupyter_output><empty_output><jupyter_text>Komplexeres ModellNun versuchen wir eine komplexere Modell-Architektur. Wir fügen noch jeweils zwei Convolutional Layer und Pooling Layer hinzu. Wir werden auch noch einen weiteren Dense-Layer hinzufügen.<jupyter_code>model=Sequential()
model.add(Conv2D(128,kernel_size=(5,5),
                 strides=1,padding='same',activation='relu',input_shape=(28,28,1)))
model.add(MaxPool2D(pool_size=(3,3),strides=2,padding='same'))
model.add(Conv2D(64,kernel_size=(2,2),
                strides=1,activation='relu',padding='same'))
model.add(MaxPool2D((2,2),2,padding='same'))
model.add(Conv2D(32,kernel_size=(2,2),
                strides=1,activation='relu',padding='same'))
model.add(MaxPool2D((2,2),2,padding='same'))
          
model.add(Flatten())

model.add(Dense(units=256,activation='relu'))
model.add(Dropout(rate=0.3))
model.add(Dense(units=128,activation='relu'))
model.add(Dropout(rate=0.3))
model.add(Dense(units=24,activation='softmax'))
model.summary()

model.compile(optimizer='adam',loss='categorical_crossentropy',metrics=['accuracy'])
plot_model(model, show_shapes=True, show_layer_names=True)
history = model.fit(X_train,y_train_oh,
         epochs = 20,
          shuffle=1,
           validation_data=(X_test,y_test_oh),
         )
show_accuracy_loss_plot(history, num_epochs=20)<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.11396329365079365, 'fraction_numerical': 0.01847718253968254, 'mean_word_length': 6.01304347826087, 'pattern_counts': {'":': 2, '<': 45, '<?xml version=': 0, '>': 45, 'https://': 3, 'lorem ipsum': 0, 'www.': 2, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 4, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '11', 'dir': 'jupyter-structured-clean-dedup', 'id': '355049', 'license': 'MIT', 'n_tokens_mistral': 2951, 'n_tokens_neox': 2905, 'n_words': 654, 'path': 'Woche 4/4_5_Bilderkennung_1.ipynb', 'repo_name': 'sting-aree/openhpi-kipraxis', 'size': '8064'}