<jupyter_start><jupyter_text>RELU EN MAX POOLING      Het convolutioneel neuraal netwerk van KIKS past convoluties toe op een foto. Nadien wordt de bekomen tensor onderworpen aan de niet-lineaire activatiefunctie ReLU en een max pooling-operatie.  Via convolutie gaat men op zoek naar verschillende kenmerken in een afbeelding. Men kan er bv. randen mee detecteren, ruis in een beeld mee verminderen of het contrast in een beeld verzachten.De kenmerken die het minst leiden tot een juiste classificatie worden verzwakt door na de convolutie een niet-lineaire activatiefunctie ReLU toe te passen; ReLU zal alle negatieve waarden op nul zal zetten. Tot slot past men ook nog een max pooling-operatie toe, die net de kenmerken die het meest leiden tot een juist classificatie zal versterken. Dan gaat men van elk venster van 2 op 2 pixels enkel de grootste waarde, dus de helderste pixel, behouden. De afbeelding wordt zo vier keer kleiner, wat ook de nodige rekenkracht verkleint.    Nodige modules importeren<jupyter_code>import numpy as np
import matplotlib.pyplot as plt
import scipy.signal
from keras.datasets import mnist<jupyter_output><empty_output><jupyter_text>1. Inlezen van data<jupyter_code># MNIST dataset inladen
(x_train, y_train), (x_test, y_test) = mnist.load_data()
# een afbeelding uit de MNIST trainingset
plt.imshow(x_train[11], cmap="gray", vmin=0, vmax=255)
print(x_train[11])
print("Het label van deze afbeelding is: ", y_train[11])
# een afbeelding uit de MNIST trainingset
plt.imshow(x_train[12], cmap="gray")
print(x_train[12])
print("Het label van deze afbeelding is: ", y_train[12])
# verderwerken met tweede afbeelding uit MNIST trainingset
drie = x_train[12]
print(drie.shape)<jupyter_output><empty_output><jupyter_text>2. ReLU en max pooling definiëren<jupyter_code>def relu(tensor):
    """RelU(x) = max(0,x)."""
    return np.maximum(0, tensor)<jupyter_output><empty_output><jupyter_text><jupyter_code>def maxpool(tensor):
    """Neemt van elk vak van 2x2 de grootste waarde."""
    mp = np.zeros((tensor.shape[0]//2, tensor.shape[1]//2))    # NumPy array van gewenste grootte, opgevuld met nullen
    # NumPy array opvullen
    for i in range(0, tensor.shape[0]-1, 2):                   # stappen van 2
        for j in range(0, tensor.shape[1]-1, 2):
            max = np.max([tensor[i][j], tensor[i][j+1], tensor[i+1][j], tensor[i+1][j+1]])
            k = i // 2              # // gebruiken om int te bekomen
            l = j // 2
            mp[k][l] = max
    return mp<jupyter_output><empty_output><jupyter_text>3. ReLU en max pooling toepassen op gefilterde afbeelding                  3.1 Filter toepassen op afbeelding<jupyter_code># filter
rand_kernel = np.array([[-1,-1,-1],[-1,8,-1],[-1,-1,-1]])
# sobel_kernel = np.array([[1,2,1],[0,0,0],[-1,-2,-1]])
# edge_kernel = np.array([[-1, -2, -1], [-2, 12, -2], [-1, -2, -1]]) 
# smooth_kernel = np.array([[1, 1, 1], [1, 5, 1], [1, 1, 1]]) / 13
# convolutie uitvoeren
drie_rand = scipy.signal.convolve2d(drie, rand_kernel, mode="valid")   # met valid laat je toe dat afbeelding iets kleiner wordt
plt.imshow(drie_rand, cmap="gray")
print(drie_rand.shape)<jupyter_output><empty_output><jupyter_text>De gefilterde afbeelding is iets kleiner dan de oospronkelijke afbeelding.<jupyter_code>print(np.min(drie), np.max(drie))
print(np.min(drie_rand), np.max(drie_rand))<jupyter_output><empty_output><jupyter_text>De oorspronkelijke afbeelding heeft pixelwaarden van 0 t.e.m. 255.De gefilterde afbeelding heeft grotere pixelwaarden en ook negatieve pixelwaarden.             3.2 ReLU toepassen op gefilterde afbeelding<jupyter_code># ReLU toepassen op de gefilterde afbeelding
drie_rand_ReLU = relu(drie_rand)
plt.imshow(drie_rand_ReLU , cmap="gray")
print(drie_rand_ReLU.shape)<jupyter_output><empty_output><jupyter_text>3.3 Max pooling toepassen op resultaat van ReLU<jupyter_code>drie_rand_ReLU_maxpool = maxpool(drie_rand_ReLU)
plt.imshow(drie_rand_ReLU_maxpool, cmap="gray")
print(drie_rand_ReLU_maxpool.shape)<jupyter_output><empty_output><jupyter_text>Opdracht 3.1Probeer eens een andere filter uit en bekijk het resultaat.             4. ReLU en max pooling toepassen op gefilterde foto uit de KIKS dataset<jupyter_code># foto uit de KIKS-dataset
testfoto = np.load("images/pseudozanguebariae.npy")
# testfoto2 = np.load("images/eugenioides.npy")
plt.figure(figsize=(12,8))
plt.imshow(testfoto, cmap="gray", vmin=0, vmax=255)
testfoto.shape<jupyter_output><empty_output><jupyter_text>Om een foto te verscherpen, kan je de volgende filter gebruiken: $\begin{bmatrix} 0 & -1 & 0 \\ -1 & 5 & -1 \\ 0 & -1 & 0   \end{bmatrix}$. Geef deze filter in in Python met de juiste instructie.<jupyter_code>scherp_kernel = np.array([[0,-1,0],[-1,5,-1],[0,-1,0]])
plt.figure(figsize=(12,8))
testfoto_scherp = scipy.signal.convolve2d(testfoto, scherp_kernel, mode="valid")
plt.imshow(testfoto_scherp, cmap="gray", vmin=0, vmax=255)
plt.figure(figsize=(12,8))
testfoto_scherp_ReLU = relu(testfoto_scherp)
plt.imshow(testfoto_scherp_ReLU, cmap="gray",  vmin=0, vmax=255)<jupyter_output><empty_output><jupyter_text>De kenmerken die minder van belang zijn om de huidmondjes te herkennen, zijn verzwakt.<jupyter_code>plt.figure(figsize=(12,8))
testfoto_scherp_ReLU_maxpool = maxpool(testfoto_scherp_ReLU)
plt.imshow(testfoto_scherp_ReLU_maxpool, cmap="gray",  vmin=0, vmax=255)
testfoto_scherp_ReLU_maxpool.shape<jupyter_output><empty_output><jupyter_text>Je merkt dat de kwaliteit van de foto's nog steeds vrij goed is na de max pooling. De kenmerken die van belang zijn om de huidmondjes te herkennen, zijn versterkt; de andere kenmerken zijn weggelaten.Bijkomend voordeel: het aantal pixels is gedeeld door vier; rekenen met kleinere afbeeldingen vergt minder rekenkracht.   Opdracht 4.1Probeer eens een andere filter uit en bekijk het resultaat.             5. ReLU en max pooling toepassen op gefilterde foto van bamboe<jupyter_code># foto inladen
bamboe =  np.load("images/bamboe.npy")
print(bamboe.shape)
plt.imshow(bamboe, cmap="gray")
# filter om verticale lijnen te detecteren
vertic_filter = np.array([[-1,0,1],[-1,0,1],[-1,0,1]])
bamboe_vertic = scipy.signal.convolve2d(bamboe, vertic_filter, mode="valid")

plt.figure(figsize=(12,18))
plt.subplot(1,2,1)                                        # plot met meerdere afbeeldingen
plt.imshow(bamboe, cmap="gray")
plt.subplot(1,2,2)
plt.imshow(bamboe_vertic, cmap="gray")

plt.show()
# ReLU toepassen op gefilterde foto
bamboe_vertic_relu = relu(bamboe_vertic)

plt.figure(figsize=(12,18))
plt.subplot(1,2,1)                                        # plot met meerdere afbeeldingen
plt.imshow(bamboe_vertic, cmap="gray")
plt.subplot(1,2,2)
plt.imshow(bamboe_vertic_relu, cmap="gray")

plt.show()
# max pooling toepassen op resultaat van ReLU
bamboe_vertic_relu_maxpool = maxpool(bamboe_vertic_relu)

plt.figure(figsize=(12,18))
plt.subplot(1,2,1)                                        # plot met meerdere afbeeldingen
plt.imshow(bamboe_vertic_relu, cmap="gray")
plt.subplot(1,2,2)
plt.imshow(bamboe_vertic_relu_maxpool, cmap="gray")

plt.show()
print(np.min(bamboe), np.max(bamboe), bamboe.shape)
print(np.min(bamboe_vertic), np.max(bamboe_vertic), bamboe_vertic.shape)
print(np.min(bamboe_vertic_relu), np.max(bamboe_vertic_relu), bamboe_vertic_relu.shape)
print(np.min(bamboe_vertic_relu_maxpool), np.max(bamboe_vertic_relu_maxpool), bamboe_vertic_relu_maxpool.shape)
# histogram met verdeling van de pixelwaarden
plt.figure(figsize=(12,18))

plt.subplot(2,2,1)                                        # plot met meerdere afbeeldingen
plt.hist(bamboe.ravel(), bins=11) 
plt.subplot(2,2,2)
plt.hist(bamboe_vertic.ravel(), bins=11)                  # kleuren verdelen over 11 intervallen
plt.subplot(2,2,3)
plt.hist(bamboe_vertic_relu.ravel(), bins=11)
plt.subplot(2,2,4)
plt.hist(bamboe_vertic_relu_maxpool.ravel(), bins=11)

plt.show()<jupyter_output><empty_output><jupyter_text>Extra uitleg over werking vertic_filter<jupyter_code>vier = np.array([[0, 0, 1, 1, 0, 0, 0, 1, 1, 0, 0], 
                 [0, 0, 1, 1, 0, 0, 0, 1, 1, 0, 0],
                 [0, 0, 1, 1, 0, 0, 0, 1, 1, 0, 0], 
                 [0, 0, 1, 1, 0, 0, 0, 1, 1, 0, 0],
                 [0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0], 
                 [0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0], 
                 [0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0], 
                 [0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0], 
                 [0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0], 
                 [0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0]])
plt.imshow(vier, cmap="gray")
vertic_filter = np.array([[-1,0,1],[-1,0,1],[-1,0,1]])<jupyter_output><empty_output><jupyter_text>Reken zelf manueel het resultaat uit van de convolutie en vergelijk met het resultaat van de code hieronder.<jupyter_code># filter toepassen op de afbeelding
vier_vertic = scipy.signal.convolve2d(vier, vertic_filter, mode="valid")
print(vier_vertic)
plt.imshow(vier_vertic, cmap="gray")<jupyter_output><empty_output>
StarcoderdataJupyterStructuredCleanDedup