Je eerste Tensorflow machine learning script!
TensorFlow is een framework wat erg geschikt is voor machine learning. Het framework is ontwikkeld door Google Brain en o.a. beschikbaar voor Python. Én het is gratis te gebruiken!
Om een beetje gevoel te krijgen met TensorFlow zijn er een aantal datasets beschikbaar. Eentje daarvan is MNIST. Dit is een verzameling van handgeschreven getallen. Het doel is om een model te maken wat kan voorspellen welk getal er opgeschreven is.
(Met vele verschillende handschriften kan dit nog wel eens een probleem zijn..)
Onderstaand vind je alle stappen en een Python script. Probeer het zelf in je eigen Python editor!
* Je hebt hier wel de matplotlib en numpy libaries voor nodig!
Inhoudsopgave
PIP: Tensorflow Library installeren
De complete TensorFlow library is te installeren met pip:
pip install -upgrade tensorflow
Notebook: Een Tensorflow script schrijven
En nu kan het schrijven beginnen. In dit voorbeeld werk ik vanuit een Jupyter notebook, maar gebruik gerust een andere editor.
1 – Importeren
De eerste stap is het importeren van de TensorFlow library en het kiezen van de gewenste dataset:
import tensorflow as tf
mnist = tf.keras.datasets.mnist
Je ziet dat de library met tf aangeroepen wordt en de dataset krijgt de naam mnist.
2 – Train & Test set
Het maken van machine learning modellen gebeurt bijna altijd met een train en een test set. De train set zorgt dat het model gaat leren van bestaande antwoorden om de juiste voorspelling te doen bij nieuwe handgeschreven cijfers. Het gemaakte model kun je vervolgens testen met de test set, want deze data is niet gebruikt bij het trainen.
De handige TensorFlow library maakt 4 datasets aan:
– y_train = de waarde die je gaat voorspellen
– x_train = de kolommen waarmee je de voorspelling gaat doen
– x_test = deze waarden ga je na het trainen aan het model voeren om voorspellingen te doen
– y_test = de voorspellingen van x_test ga je vergelijken met y_test. Klopt de voorspelling met de echte waarde?
Code:
(x_train, y_train), (x_test, y_test) = mnist.load_data()
3 – Voorbeeld dataset
Laten we eens de eerste rij van x_train en y_train pakken om te zien hoe de data er uit ziet.
Y_train rij 1 = [5]
X_train rij 1 = 28 rijen x 28 kolommen met waardes tussen 0 en 255
Dit klinkt gek, maar is niets anders dan een tabelweergave van een afbeelding: 28×28 pixels met 255 kleurcodes.
x_train bevat dus de pixels van de afbeelding en y_train het cijfer dat de afbeelding weergeeft. De waardes van 0 tot 255 zetten we vervolgens om naar waardes tussen 0 en 1. Dit voorspelt makkelijker.
x_train = tf.keras.utils.normalize(x_train, axis=1)
x_test = tf.keras.utils.normalize(x_test, axis=1)
Zoals je ziet is de data helemaal ingericht op de TensorFlow functies. Normaal gesproken is het klaarmaken (pre-processing) van je data één van de moeilijkste klussen van je data project.
4 – Check
Benieuwd hoe het eerste cijfer van je x_train set er uit ziet? Probeer de volgende code:
import matplotlib.pyplot as plt
plt.imshow(x_train[0], cmap = plt.cm.binary)
plt.show
5 – Model
Nu de data op orde is, moet het model getraind worden.
Onderstaande code maakt een model en voegt daar vier layers aan toe. Door middel van de layers wordt een neuraal netwerk gecreëerd. Dit netwerk bestaat uit verschillende vermenigvuldigingen en drempels om het juiste cijfers als output te genereren.
Vervolgens worden er in compile verschillende instellingen meegegeven. De mogelijkheden zijn hierbij enorm. In de laatste stap wordt het model voorzien van de trainingsdata en wordt bepaald dat het model drie keer de gehele dataset doorloopt.
model = tf.keras.models.Sequential()
model.add(tf.keras.layers.Flatten())
model.add(tf.keras.layers.Dense(128, activation=tf.nn.relu))
model.add(tf.keras.layers.Dense(128, activation=tf.nn.relu))
model.add(tf.keras.layers.Dense(10, activation=tf.nn.softmax))
model.compile(optimizer = 'adam', loss = 'sparse_categorical_crossentropy', metrics=['accuracy'])
model.fit(x_train, y_train, epochs=3)
Zoals je ziet in de epochs hebben we 6000 samples om het model te trainen. Deze zijn drie keer doorlopen en de accuracy (nauwkeurigheid) van het model steeg bij elke epoch.
6 – Evaluatie & Opslaan
Vervolgens gaan we de x_test en y_test set gebruiken om de accuracy te meten als we het model nieuwe waarden geven.
val_loss, val_acc = model.evaluate(x_test,y_test)
print(val_loss, val_acc)
Ook slaan we het model op:
model.save('model_test_123')
new_model= tf.keras.models.load_model('model_test_123')
7 – Voorspellingen
Het model heeft nu de naam new_model. Dit kunnen we gebruiken om het toe te passen op nieuwe datasets. We gaan nu een lijst voorspellingen maken op basis van de afbeeldingen in dataset x_test.
predictions = new_model.predict([x_test])
Check
Uit de lijst met predictions gaan we nu (met Numpy) een voorspelling checken. Hiervoor pakken we rij [7]. Dit is de achtste rij van de predictions lijst, want Python telt [0] ook mee.
import numpy as np
print(np.argmax(predictions[7]))
Resultaat = Voorspelling: 9
Nu moeten we kijken of de afbeelding ook echt een 9 is. Dat doen we door in x_test[7] te kijken. Deze rij moeten we met een Matplotlib figuur zichtbaar maken.
plt.imshow(x_test[7])
plt.show
Resultaat = Een 9!
Succes!
Je eerste machine learning model is een feit. Probeer vooral de stappen van het model te begrijpen. In dit voorbeeld zijn we niet in gegaan op de details van het model en werd de data perfect aangeleverd. In de praktijk komt dit haast niet voor.
Toch is dit voorbeeld een mooie opstap naar andere projecten. Kijk bijvoorbeeld in de documentatie van TensorFlow, op Kaggle of YouTube voor meer inspiratie.
Meer over tensorflow vind je hier: www.tensorflow.org
Hieronder vind je de complete code voor Jupyter notebook.
Gebruik je een andere editor, dan kan het zijn dat de Matplotlib functies wat extra code nodig hebben om visualisaties te runnen.
import tensorflow as tf
mnist = tf.keras.datasets.mnist
(x_train, y_train), (x_test, y_test) = mnist.load_data()
x_train = tf.keras.utils.normalize(x_train, axis=1)
x_test = tf.keras.utils.normalize(x_test, axis=1)
import matplotlib.pyplot as plt
plt.imshow(x_train[0], cmap = plt.cm.binary)
plt.show
model = tf.keras.models.Sequential()
model.add(tf.keras.layers.Flatten())
model.add(tf.keras.layers.Dense(128, activation=tf.nn.relu))
model.add(tf.keras.layers.Dense(128, activation=tf.nn.relu))
model.add(tf.keras.layers.Dense(10, activation=tf.nn.softmax))
model.compile(optimizer = 'adam', loss = 'sparse_categorical_crossentropy', metrics=['accuracy'])
model.fit(x_train, y_train, epochs=3)
val_loss, val_acc = model.evaluate(x_test,y_test)
print(val_loss, val_acc)
model.save('model_test_123')
new_model= tf.keras.models.load_model('model_test_123')
predictions = new_model.predict([x_test])
import numpy as np
print(np.argmax(predictions[7]))
plt.imshow(x_test[7])
plt.show
Deze tutorial is ook beschikbaar in het Engels / This tutorial is also available in English.