3 Implémentation des couches CNN

Dans cette section, nous allons implémenter couches convolutives (CONV) et pooling (POOL) dans numpy
pour vous expliquer l'opération de convolution ainsi d'appliquer deux types différents d'opération de
pooling.

“
Objective de ce chapitre

3.1 Packages

Importons d'abord tous les packages dont vous aurez besoin lors de cette section.

import numpy as np
import h5py
import matplotlib.pyplot as plt

%matplotlib inline
plt.rcParams['figure.figsize'] = (5.0, 4.0) # set default size of plots
plt.rcParams['image.interpolation'] = 'nearest'
plt.rcParams['image.cmap'] = 'gray'

%load_ext autoreload
%autoreload 2

np.random.seed(1)

3.2 Zero-Padding

Cette fonction Zero-padding ajoute des zéros autour de la bordure d'une image. Ci dessous un exemple
avec pad=1.
Pour rappel, les principaux avantages du remplissage(padding) sont:

Il permet d'utiliser une couche CONV sans forcément réduire la hauteur et la largeur des volumes. Ceci

est important pour construire des réseaux plus profonds, car sinon la hauteur / largeur diminuerait à
mesure que vous iriez vers des couches plus profondes. Un cas particulier important est la «même»

convolution, dans laquelle la hauteur / largeur est exactement préservée après une couche.
Cela nous aide à conserver davantage d'informations au bord d'une image. Sans remplissage, très peu

de valeurs du calque suivant seraient affectées par des pixels sur les bords d'une image.

3.2.1 Exercice

Implémentez la fonction suivante zero_pad , qui remplit toutes les images d'un lot d'exemples X avec des
zéros. (Hint, utiliser numpy.pad)

A noter si vous voulez remplir le array "a" de forme avec pad = 1 pour la 2ème dimension, pad
= 3 pour la 4ème dimension et pad = 0 pour le reste, vous feriez:

a = np.pad(a, ((0,0), (1,1), (0,0), (3,3), (0,0)), 'constant', constant_values =

(..,..))

# GRADED FUNCTION: zero_pad

def zero_pad(X, pad):

"""
Pad with zeros all images of the dataset X. The padding is applied to the
height and width of an image,
as illustrated in Figure 1.

Argument:
 X -- python numpy array of shape (m, n_H, n_W, n_C) representing a batch of m
images
pad -- integer, amount of padding around each image on vertical and horizontal
dimensions

Returns:
X_pad -- padded image of shape (m, n_H + 2*pad, n_W + 2*pad, n_C)
"""

### START CODE HERE ### (≈ 1 line)

### END CODE HERE ###

return X_pad

Expected output:

np.random.seed(1)
x = np.random.randn(4, 3, 3, 2)
x_pad = zero_pad(x, 2)
print ("x.shape =", x.shape)
print ("x_pad.shape =", x_pad.shape)
print ("x[1, 1] =", x[1, 1])
print ("x_pad[1, 1] =", x_pad[1, 1])

fig, axarr = plt.subplots(1, 2)

axarr[0].set_title('x')
axarr[0].imshow(x[0,:,:,0])
axarr[1].set_title('x_pad')
axarr[1].imshow(x_pad[0,:,:,0])
3.3 Une seule étape de convolution

Dans cette partie, implémentez une seule étape de convolution, dans laquelle vous appliquez le filtre à une
seule position de l'entrée. Cela sera utilisé pour construire une unité convolutive, qui:

Prend un volume d'entrée

Applique un filtre à chaque position de l'entrée

Produit un autre volume (généralement de taille différente)

Dans cette première étape de l'exercice, vous implémenterez une seule étape de convolution,
correspondant à l'application d'un filtre à une seule des positions pour obtenir une seule sortie à valeur
réelle.

3.3.1 Exercice

Implémentez conv_single_step ().

Hint: Utilisez np.multiply() et np.sum()

# GRADED FUNCTION: conv_single_step

def conv_single_step(a_slice_prev, W, b):

"""
Apply one filter defined by parameters W on a single slice (a_slice_prev) of
the output activation
of the previous layer.

Arguments:
a_slice_prev -- slice of input data of shape (f, f, n_C_prev)
W -- Weight parameters contained in a window - matrix of shape (f, f,
n_C_prev)
b -- Bias parameters contained in a window - matrix of shape (1, 1, 1)

Returns:
Z -- a scalar value, result of convolving the sliding window (W, b) on a slice
x of the input data
"""

### START CODE HERE ### (≈ 2 lines of code)

### END CODE HERE ###

return Z

Expected output:
 np.random.seed(1)
a_slice_prev = np.random.randn(3, 3, 3)
W = np.random.randn(3, 3, 3)
b = np.random.randn(1, 1, 1)

Z = conv_single_step(a_slice_prev, W, b)
print("Z =", Z)

assert (type(Z) == np.float64 or type(Z) == np.float32), "You must cast the output
to float"
assert np.isclose(Z, -10.624), "Wrong value"

3.4 Réseaux de neurones convolutifs - Passe avant

Dans la passe avant, vous prendrez de nombreux filtres et les convolverez sur l'entrée. Chaque
«convolution» vous donne une sortie de matrice 2D. Vous allez ensuite empiler ces sorties pour obtenir un
volume 3D:

3.4.1 Exercice

Implémentez la fonction ci-dessous pour convoluer les filtres W sur une activation d'entrée A_prev. Cette
fonction prend comme entrée A_prev, les activations sorties par la couche précédente (pour un lot de m
entrées), F filtres / poids notés W, et un vecteur de biais noté b, où chaque filtre a son propre (unique) biais.
Enfin, vous avez également accès au dictionnaire des hyperparamètres qui contient la foulée et le
remplissage.

Hint:

1. Pour sélectionner une tranche 2x2 dans le coin supérieur gauche d'une matrice "a_prev" (shape
(5,5,3)), vous feriez:

a_slice_prev = a_prev[0:2,0:2,:]

2. Pour définir une_slice, vous devrez d'abord définir ses coins vert_start, vert_end, horiz_start et
horiz_end. Cette figure peut vous aider à trouver comment chacun des coins peut être défini à l'aide
de h, w, f et s dans le code ci-dessous.
 3. Pour cet exercice, nous ne nous soucierons pas de la vectorisation, et nous implémenterons
simplement tout avec des boucles for.

4. C'est une couche de "Same convolutions" qu'on réalise.

# GRADED FUNCTION: conv_forward

def conv_forward(A_prev, W, b, hparameters):

"""
Implements the forward propagation for a convolution function

Arguments:
A_prev -- output activations of the previous layer, numpy array of shape (m,
n_H_prev, n_W_prev, n_C_prev)
W -- Weights, numpy array of shape (f, f, n_C_prev, n_C)
b -- Biases, numpy array of shape (1, 1, 1, n_C)
hparameters -- python dictionary containing "stride" and "pad"

Returns:
Z -- conv output, numpy array of shape (m, n_H, n_W, n_C)
cache -- cache of values needed for the conv_backward() function
"""

### START CODE HERE ###

### END CODE HERE ###

# Making sure your output shape is correct

assert(Z.shape == (m, n_H, n_W, n_C)), "Wrong shape of Z"
 # Save information in "cache" for the backprop
cache = (A_prev, W, b, hparameters)

return Z, cache

Expected output:

np.random.seed(1)
A_prev = np.random.randn(10, 10, 10, 4)
W = np.random.randn(3, 3, 4, 8)
b = np.random.randn(1, 1, 1, 8)
hparameters = {"pad" : 1,
"stride": 2}

Z, cache_conv = conv_forward(A_prev, W, b, hparameters)

print("Z's shape = ", Z.shape)
print("Z's mean = ", np.mean(Z))
print("Z[0,2,1] = ", Z[0, 2, 1])
print("cache_conv[0][1][2][3] = ", cache_conv[0][1][2][3])

Z's shape = (10, 5, 5, 8)

Z's mean = 21.507310252637364
Z[0,2,1] = [ 40.08031464 31.63067629 11.86814635 27.68257079 6.60340939
34.95518664 -17.77169157 16.65830541]
cache_conv[0][1][2][3] = [-0.4148469 0.45194604 -1.57915629 -0.82862798]

3.5 Couche de Max-Pooling & Average-Pooling

Vous allez maintenant implémenter MAX-POOL et AVG-POOL, dans la même fonction.

3.5.1 Exercice

# GRADED FUNCTION: pool_forward

def pool_forward(A_prev, hparameters, mode):

 """
Implements the forward pass of the pooling layer

Arguments:
A_prev -- Input data, numpy array of shape (m, n_H_prev, n_W_prev, n_C_prev)
hparameters -- python dictionary containing "f" and "stride"
mode -- the pooling mode you would like to use, defined as a string ("max" or
"average")

Returns:
A -- output of the pool layer, a numpy array of shape (m, n_H, n_W, n_C)
cache -- cache used in the backward pass of the pooling layer, contains the
input and hparameters
"""

# Retrieve dimensions from the input shape

(m, n_H_prev, n_W_prev, n_C_prev) = A_prev.shape

# Retrieve hyperparameters from "hparameters"

f = hparameters["f"]
stride = hparameters["stride"]

# Define the dimensions of the output

n_H = int(1 + (n_H_prev - f) / stride)
n_W = int(1 + (n_W_prev - f) / stride)
n_C = n_C_prev

# Initialize output matrix A

A = np.zeros((m, n_H, n_W, n_C))

### START CODE HERE ###

### END CODE HERE ###

# Store the input and hparameters in "cache" for pool_backward()

cache = (A_prev, hparameters)

# Making sure your output shape is correct

assert(A.shape == (m, n_H, n_W, n_C))

return A, cache

Expected output:

# Case 1: stride of 1
np.random.seed(1)
A_prev = np.random.randn(2, 5, 5, 3)
hparameters = {"stride" : 1, "f": 3}

A, cache = pool_forward(A_prev, hparameters, mode = "max")

print("mode = max")
print("A.shape = " + str(A.shape))
print("A[1, 1] =\n", A[1, 1])
print()
A, cache = pool_forward(A_prev, hparameters, mode = "average")
print("mode = average")
print("A.shape = " + str(A.shape))
print("A[1, 1] =\n", A[1, 1])

mode = max
A.shape = (2, 3, 3, 3)
A[1, 1] =
[[1.96710175 0.84616065 1.27375593]
[1.96710175 0.84616065 1.23616403]
[1.62765075 1.12141771 1.2245077 ]]

mode = average
A.shape = (2, 3, 3, 3)
A[1, 1] =
[[ 0.44497696 -0.00261695 -0.31040307]
[ 0.50811474 -0.23493734 -0.23961183]
[ 0.11872677 0.17255229 -0.22112197]]

# Case 2: stride of 2
np.random.seed(1)
A_prev = np.random.randn(2, 5, 5, 3)
hparameters = {"stride" : 2, "f": 3}

A, cache = pool_forward(A_prev, hparameters, mode = "max")

print("mode = max")
print("A.shape = " + str(A.shape))
print("A[0] =\n", A[0])
print()

A, cache = pool_forward(A_prev, hparameters, mode = "average")

print("mode = average")
print("A.shape = " + str(A.shape))
print("A[1] =\n", A[1])

mode = max
A.shape = (2, 2, 2, 3)
A[0] =
[[[1.74481176 0.90159072 1.65980218]
[1.74481176 1.6924546 1.65980218]]

[[1.13162939 1.51981682 2.18557541]

[1.13162939 1.6924546 2.18557541]]]
mode = average
A.shape = (2, 2, 2, 3)
A[1] =
[[[-0.17313416 0.32377198 -0.34317572]
[ 0.02030094 0.14141479 -0.01231585]]

[[ 0.42944926 0.08446996 -0.27290905]

[ 0.15077452 0.28911175 0.00123239]]]