Practicum KI

Hoe kan je Kunstmatige Intelligentie trainen?

Zoals we eerder hadden uitgelegd, zijn er drie verschillende manieren om een Kunstmatige Intelligentie te trainen. Artificial SuperIntelligence (ASI) is de meest intelligente AI, met bovenmenselijke capaciteiten. Artificial General Intelligence AGI zou vergelijkbare capaciteiten moeten hebben als de mensen, bijvoorbeeld om doktoren te helpen tijdens een moeilijke operatie. De derde vorm is Artificial Narrow Intelligence (ANI) de minst geavanceerde vorm. ANI zien we nu al overal om ons heen. Zoals de virtuele assistenten van Apple en Google, of de gezichtsherkenning die we continu gebruiken om onze telefoon te ontgrendelen. Kunstmatige Intelligenties die bijvoorbeeld spellen spelen, moet eerst getrained worden met tienduizenden uren of miljoenen potjes om werkende resultaten te krijgen. Ze trainen dus met meer informatie dan een mens ooit kan.

Omdat ASI en AGI technologisch nog bijna niet mogelijk is maken wij hier(net zoals de meeste bedrijven) gebruik van Artificial Narrow Intelligence. Dat betekent dus ook dat wij gaan trainen of basis van ervaring met heel veel data, zodat onze Kunstmatige Intelligentie daarna zelf nauwkeurig kan voorspellen wat het is. Omdat we gebruik maken van ANI, betekent het dat hij als we een foto van een mens laten zien, terwijl hij getraind is op vogels en vliegtuigen, de Kunstmatige Intelligentie kiest uit ervaring tot welke categorie het behoort. De Kunstmatige Intelligentie zal dan zoeken naar elementen van één van de twee categorieën, zoals de achtergrond in de foto en de vorm van het object (in dit geval een mens). Om te beginnen met het trainen van je eigen Kunstmatige Intelligentie, heb je in ieder geval drie dingen nodig.

1. Data

Toegang hebben tot veel en goede data is heel belangrijk om het trainingsproces goed te laten verlopen. Door goed gemarkeerde data te gebruiken loopt het trainingsproces vaak sneller want hij herkent dan sneller wat goed is en wat niet in plaats van dat hij eerst leert dat iets fout goed is en er conflicten ontstaan. Voor ons practicum om het verschil te detecteren tussen een vogel en een vliegtuig gebruiken wij veel data in de vorm van foto’s van vliegtuigen en vogels. Wij hebben hiervoor de verschillende vogel en vliegtuigsoorten gebruikt die ook echt bij een vliegveld, Schiphol in ons geval te zien zijn. Alle afbeeldingen hebben we in twee aparte mappen geplaatst en gelabeld met hun soort namelijk “bird” en “plane”, zoals hiernaast te zien is.

2. Hardware

Voor het trainen van een Kunstmatige Intelligentie is redelijk wat computerkracht nodig van de CPU of GPU. Voor de soort Kunstmatige Intelligentie die wij willen gaan trainen loont het om een GPU te gebruiken. Want hoe sterker je GPU is hoe sneller de Kunstmatige Intelligentie getraind zal wordt. Daarom maken wij bij ons practicum gebruiken van een PC met Intel Core i5-6400 en een NVIDIA Geforce GTX 950 (helaas werkte onze installatie van TensorFlow niet met mijn GPU dus er was geen optimalisatie) in plaats van bijvoorbeeld een Rasperry Pi 4 waar het trainen veel langer zou duren.

3. Software

Nu gaan we een model maken en die compileren. Layers (voor het herkennen van abnormaalheden op MRI-scans) wordt gebruikt. Wij hebben ook voor TensorFlow gekozen omdat het door de vele documentatie op internet het makkelijk te leren is. TensorFlow maakt gebruik van de populaire programmeertaal Python en dat gebruiken wij dan ook.

Het begin…

We hebben nu dus onze data verzameld, besloten wat de hardware is die we gaan gebruiken en welke software.

Allereerst moeten we de nieuwste python versie downloaden dat is de programmeertaal die we gaan gebruiken. Op Windows 10 is dit makkelijk te downloaden via de Windows Store. Wij maken gebruik van Python3.8. Als dat gedownload is kun je een terminal openen en python typen om Python te starten.

Daarna moeten we TensorFlow en de vereiste libraries(andere programma’s die TensorFlow nodig heeft om te werken) downloaden en installeren. Voor de TensorFlow toepassing die wij hebben gebruikt hadden we de bèta-versie van TensorFlow nodig, maar dat is niet meer nodig omdat de functies nu ook in de stabiele-versie zit.

TensorFlow gebruiken

Eerst moeten we TensorFlow downloaden en installeren dat kan heel makkelijk met de volgende code
(De code die in de Terminal getypt moet worden zijn aangegeven in de beige vlakken)

pip install TensorFlow

Nu gaan we alle vereiste libraries importeren zodat we die later kunnen gebruiken.

Eerst importeren we een paar vereiste libraries: numpy voor het rekenen met grote arrays en het doen van berekeningen, os voor het gebruiken van bepaalde gegevens van het systeem, PIL voor het verwerken van de afbeeldingen.

import numpy as np
import os
import PIL

Daarna importeren we TensorFlow zelf. De “as tf” betekent dat we niet steeds helemaal TensorFlow hoeven te typen maar alleen “tf”

import TensorFlow as tf
from TensorFlow import keras

Layers zijn een belangrijk onderdeel van TensorFlow hierin worden de gegevens van het neural network opgeslagen. En Sequential is voor het werken met de layers.

from TensorFlow.keras import layers
from TensorFlow.keras.models import Sequential

Als laatste importeren we pathlib voor het werken met mappen op de computer.

import pathlib

We gaan nu de huidige map “Dataset” instellen als de hoofdmap met de data (dus met de twee submappen).

data_dir = pathlib.Path('./')

Om te controleren dat we in de juiste map zitten kunnen we de volgende code uitvoeren om alle jpg-afbeeldingen op te tellen. Als het goed is krijgen we dan een totaal van 200 foto’s, namelijk 100 vogels en 100 vliegtuigen.

print(len(list(data_dir.glob('*/*.jpg'))))

Nu gaan we beginnen met het maken van de datasets. Met behulp van de image_dataset_from_directory-functie kunnen we snel de afbeeldingen uit de map omzetten in een dataset.

We maken eerst een dataset voor het trainen. Hier is data_dir de map met alle afbeeldingen, We hebben hier gekozen voor een validation_split van 0.2 wat betekent dat 20% van de 200 afbeeldingen gebruikt wordt voor het valideren van de afbeeldingen en dan blijft er nog 80% dus 160 afbeeldingen over voor het trainen, subset is het soort dataset en image_size het formaat waar de afbeeldingen naar geschaald worden. Hierna zie je in de terminal dat er 200 foto’s gevonden zijn in twee classes waarvan 160 gebruikt worden voor het trainen.

train_ds = tf.keras.preprocessing.image_dataset_from_directory(
 data_dir,
 validation_split=0.2,
 subset="training",
 seed=123,
 image_size=(256, 256),
 batch_size=32
)

Daarna maken we nog dataset voor het valideren dit gebruikt 20% dus 40 afbeeldingen van de 200. Hierna zie je in de terminal dat er 200 foto’s gevonden zijn in twee classes waarvan 40 gebruikt worden voor het valideren.

val_ds = tf.keras.preprocessing.image_dataset_from_directory(
 data_dir,
 validation_split=0.2,
 subset="validation",
 seed=123,
 image_size=(256, 256),
 batch_size=32
 )

Met de volgende code kunnen we de namen van de gemaakte classes bekijken. Als het goed is krijg je dan “[‘bird’, ‘plane’]”. Als je datasets met andere namen hebt gebruikt krijg je hier een ander resultaat, het is dan belangrijk dat je dit resultaat ergens opslaat want dit hebben we later nog nodig(vooral de volgorde).

print(train_ds.class_names)

Nu gaan we een model maken en die compileren. Layers zijn geavanceerde wiskundige functies waar de afbeeldingen allemaal laag voor laag doorheen gaan. We gebruiken ‘Adam’ als onze algorithm optimizer, want het werkt goed en vereist relatief weinig van het systeem.

model = Sequential([
 layers.experimental.preprocessing.Rescaling(1./255, input_shape=(256, 256, 3)),
 layers.Conv2D(16, 3, padding='same', activation='relu'),
 layers.MaxPooling2D(),
 layers.Conv2D(32, 3, padding='same', activation='relu'),
 layers.MaxPooling2D(),
 layers.Conv2D(64, 3, padding='same', activation='relu'),
 layers.MaxPooling2D(),
 layers.Flatten(),
 layers.Dense(128, activation='relu'),
 layers.Dense(2)
])

model.compile(optimizer='adam',
       loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
       metrics=['accuracy'])

En dan komt nu het spannendste het trainen van de model, epoch betekent hier hoe vaak er door alle afbeeldingen gegaan word, hier hebben we 15x gedaan.

result = model.fit(
 train_ds,
 validation_data=val_ds,
 epochs=15
)

Vervolgens willen wij de trainingsresultaten per epoch opslaan zodat we hiervan later in excel mooie grafieken van het trainingsproces van kunnen maken. Je krijgt hier dan een JSON-string met informatie over hoe accuraat het trainen en de validatie(dus met die 40 afbeeldingen) is.

result.history

En tot slot willen we het model opslaan zodat we later de Kunstmatige Intelligentie op nieuwe data kunnen testen zonder dat we het model iedere keer helemaal opnieuw moeten trainen.

model.save('../model')

Nieuwe data voorspellen

We hebben nu dus onze Kunstmatige Intelligentie getraind met de foto’s uit onze dataset en dit opgeslagen als de map ‘model’. Nu willen we natuurlijk dit model gebruiken om nieuwe data te testen en te zien of het wel echt werkt.

Hiervoor gebruiken we weer python. We moeten nu ook weer een paar libraries importeren zodat we die kunnen gebruiken. We gebruiken nu ook een paar nieuwe die we eerder niet nodig hadden. Zoals: load_modelvoor het inladen van het eerder opgeslagen model en image voor het inladen en manipuleren voor de te voorspellen afbeeldingen.

import numpy as np
import os
import TensorFlow as tf

from TensorFlow import keras
from TensorFlow.keras import layers
from TensorFlow.keras.models import Sequential
from TensorFlow.keras.models import load_model
from TensorFlow.keras.preprocessing import image

We gaan nu 3 variabelen instellen. De eerste is de map met de afbeeldingen die we willen voorspellen. Het is belangrijk dat je afbeeldingen kiest die niet gebruikt zijn bij het trainen, want dat leidt tot onterecht correcte resultaten. De tweede is de map met het model die eerder hebben opgeslagen. De derde zijn de class_names die we bij het instellen voor het trainen van het model al hebben opgeslagen, hierbij is vooral de volgorde van belang anders klopt de voorspelling niet.

images_path = 'D:/PWS/evaluation'
model_path = 'D:/PWS/model'
class_names = ['Bird', 'Plane']

Dan kunnen we nu doorgaan met het inladen van het opgeslagen model.

model = load_model(model_path)

We moeten nu ook weer het model compileren voordat we het kunnen gebruiken.

model.compile(optimizer='adam',
       loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
       metrics=['accuracy'])

Vervolgens laden we alle afbeeldingen uit bovengenoemde lijst en importeren we slaan we dit op als variabele. Intussen worden de afbeeldingen ook gewijzigd tot de goede afmetingen.

images = []
for img in os.listdir(folder_path):
  img = os.path.join(folder_path, img)
  img = image.load_img(img, target_size=(256, 256))
  img = image.img_to_array(img)
  img = np.expand_dims(img, axis=0)
  images.append(img)

images = np.vstack(images)

Nu gaan we op alle afbeeldingen voorspellingen doen.

predictions = model.predict(images)

We hebben nu alle afbeeldingen voorspelt en ze zijn opgeslagen in de variabele ‘predictions’, maar hoe komen we nou bij die data?

Dat kan door een loop te maken door de lijst van voorspellingen. Het eerst wat we dan vaststellen is de score en dat is een array van met de zekerheid van afbeelding per class_name, hiermee kunnen we bekijken wat de class_name is met de grootste zekerheid en daar de naam en percentage van laten zien. We halen voor referentie ook de naam van de afbeelding op uit de map.

for i in range(len(predictions)):
score = tf.nn.softmax(predictions[i])
imagename = os.listdir(folder_path)[i]
print(
       "{} is hopelijk een {} met {:.2f} procent zekerheid."
       .format(imagename, class_names[np.argmax(score)], 100 * np.max(score))
     )

Je krijgt als het goed is nu per afbeelding die in de voorspellingen een regel te zien die lijkt op: “bird 1559.jpg is hopelijk een Bird met 99.68 procent zekerheid.”.

Als je alle stappen exact hebt gevolgd en alles goed gaat(wat vaak niet gebeurd helaas) heb je nu een volledig getraind model die je op ieder moment kunt inladen en op nieuwe data voorspellingen kunt laten doen. In de volgende deelvraag gaan we de resultaten bespreken en kijken of het nu al op vliegvelden gebruikt zou kunnen worden.