Comment appliquer un remplissage aux tableaux avec NumPy

Le remplissage consiste à ajouter des éléments supplémentaires aux bords d’un tableau. Bien que cela semble simple, cette technique offre de nombreuses applications qui peuvent améliorer considérablement les fonctionnalités et les performances de vos tâches de traitement de données.

1. Certificat de cybersécurité Google – Accédez rapidement à une carrière dans la cybersécurité.

2. Traitement du langage naturel dans TensorFlow – Construire des systèmes PNL

3. Python pour tout le monde – Développer des programmes pour collecter, nettoyer, analyser et visualiser les données

4. Certificat professionnel d’assistance informatique Google

5. Architecte de solutions cloud AWS – Certificat Professionnel

Supposons que vous travaillez avec des données d’image. Lors de l’application de filtres ou de l’exécution d’opérations de convolution, les bords de l’image peuvent poser problème car il n’y a pas suffisamment de pixels voisins pour appliquer les opérations de manière cohérente. Le remplissage de l’image (en ajoutant des lignes et des colonnes de pixels autour de l’image d’origine) garantit que chaque pixel est traité de manière égale, ce qui se traduit par une sortie plus précise et visuellement plus agréable.

Le remplissage n’est pas limité au traitement de l’image. En apprentissage profond, il est crucial lors du travail avec des réseaux de neurones convolutifs (CNN). Il permet de conserver les dimensions spatiales de vos données à travers les couches successives du réseau, évitant ainsi que les données ne rétrécissent à chaque opération. Ceci est particulièrement important pour préserver les caractéristiques et la structure d’origine de vos données d’entrée.

Dans l’analyse de séries chronologiques, le remplissage peut aider à aligner des séquences de différentes longueurs. Cet alignement est essentiel pour alimenter les données dans les modèles d’apprentissage automatique, où la cohérence de la taille des entrées est souvent requise.

Dans cet article, vous apprendrez comment appliquer un remplissage aux tableaux avec NumPy, ainsi que les différents types de remplissage et les meilleures pratiques lors de l’utilisation de NumPy pour compléter des tableaux.

Numpy.pad

La fonction numpy.pad est l’outil incontournable de NumPy pour ajouter un remplissage aux tableaux. La syntaxe de cette fonction est la suivante :

numpy.pad(array, pad_width, mode= »constant », **kwargs)

Où :

• array : Le tableau d’entrée auquel vous souhaitez ajouter un remplissage.
• pad_width : Le nombre de valeurs ajoutées aux bords de chaque axe. Il spécifie le nombre d’éléments à ajouter à chaque extrémité des axes du tableau. Il peut s’agir d’un seul entier (même remplissage pour tous les axes), d’un tuple de deux entiers (remplissage différent pour chaque extrémité de l’axe) ou d’une séquence de tels tuples pour différents axes.
• mode : La méthode utilisée pour le rembourrage, déterminant le type de rembourrage à appliquer. Les modes courants incluent : zéro, bord, symétrique, etc.
• kwargs : Des arguments de mots-clés supplémentaires en fonction du mode.

Examinons un exemple de tableau et voyons comment nous pouvons y ajouter un remplissage à l’aide de NumPy. Pour plus de simplicité, nous nous concentrerons sur un type de remplissage : le remplissage nul, qui est le plus courant et le plus simple.

Étape 1 : Création du tableau

Tout d’abord, créons un tableau 2D simple avec lequel travailler :

import numpy as np

# Create a 2D array

array = np.array([[1, 2], [3, 4]])

print("Original Array:")

print(array)

Sortie :

Original Array:

[[1 2]

 [3 4]]

Étape 2 : ajout d’un remplissage nul

Ensuite, nous ajouterons un remplissage nul à ce tableau. Nous utilisons la fonction np.pad pour y parvenir. Nous spécifierons une largeur de remplissage de 1, en ajoutant une ligne/colonne de zéros autour de l’ensemble du tableau.

# Add zero padding

padded_array = np.pad(array, pad_width=1, mode="constant", constant_values=0)

print("Padded Array with Zero Padding:")

print(padded_array)

Sortie :

Padded Array with Zero Padding:

[[0 0 0 0]

 [0 1 2 0]

 [0 3 4 0]

 [0 0 0 0]]

Explication

• Tableau d’origine : Notre tableau de départ est un simple tableau 2×2 avec des valeurs [[1, 2], [3, 4]].
• Rembourrage nul : En utilisant np.pad, nous ajoutons une couche de zéros autour du tableau d’origine. L’argument pad_width=1 spécifie qu’une ligne/colonne de remplissage est ajoutée de chaque côté. L’argument mode="constant" indique que le remplissage doit être une valeur constante, que nous mettons à zéro avec constant_values=0.

Types de rembourrage

Il existe différents types de remplissage, le remplissage zéro, qui a été utilisé dans l’exemple ci-dessus, en fait partie ; d’autres exemples incluent le remplissage constant, le remplissage de bord, le remplissage réfléchissant et le remplissage symétrique. Discutons de ces types de rembourrage en détail et voyons comment les utiliser.

Rembourrage nul

Le remplissage nul est la méthode la plus simple et la plus couramment utilisée pour ajouter des valeurs supplémentaires aux bords d’un tableau. Cette technique consiste à remplir le tableau avec des zéros, ce qui peut être très utile dans diverses applications, telles que le traitement d’images.

Le remplissage de zéros implique l’ajout de lignes et de colonnes remplies de zéros aux bords de votre tableau. Cela permet de conserver la taille des données tout en effectuant des opérations qui pourraient autrement les réduire.

Exemple :

import numpy as np



array = np.array([[1, 2], [3, 4]])

padded_array = np.pad(array, pad_width=1, mode="constant", constant_values=0)

print(padded_array)

Sortie :

[[0 0 0 0]

 [0 1 2 0]

 [0 3 4 0]

 [0 0 0 0]]

Rembourrage constant

Le remplissage constant vous permet de remplir le tableau avec une valeur constante de votre choix, pas seulement des zéros. Cette valeur peut être celle de votre choix, comme 0, 1 ou tout autre nombre. C’est particulièrement utile lorsque vous souhaitez maintenir certaines conditions aux limites ou lorsque le remplissage nul peut ne pas convenir à votre analyse.

Exemple :

array = np.array([[1, 2], [3, 4]])

padded_array = np.pad(array, pad_width=1, mode="constant", constant_values=5)

print(padded_array)

Sortie :

[[5 5 5 5]

 [5 1 2 5]

 [5 3 4 5]

 [5 5 5 5]]

Rembourrage des bords

Le remplissage des bords remplit le tableau avec les valeurs du bord. Au lieu d’ajouter des zéros ou une valeur constante, vous utilisez la valeur de bord la plus proche pour combler les lacunes. Cette approche permet de conserver les modèles de données d’origine et peut s’avérer très utile lorsque vous souhaitez éviter d’introduire des valeurs nouvelles ou arbitraires dans vos données.

Exemple :

array = np.array([[1, 2], [3, 4]])

padded_array = np.pad(array, pad_width=1, mode="edge")

print(padded_array)

Sortie :

[[1 1 2 2]

 [1 1 2 2]

 [3 3 4 4]

 [3 3 4 4]]

Rembourrage réfléchissant

Le remplissage réfléchi est une technique dans laquelle vous remplissez le tableau en reflétant les valeurs des bords du tableau d’origine. Cela signifie que les valeurs de bordure sont reflétées sur les bords, ce qui permet de maintenir les modèles et la continuité de vos données sans introduire de valeurs nouvelles ou arbitraires.

Exemple :

array = np.array([[1, 2], [3, 4]])

padded_array = np.pad(array, pad_width=1, mode="reflect")

print(padded_array)

Sortie :

[[4 3 4 3]

 [2 1 2 1]

 [4 3 4 3]

 [2 1 2 1]]

Rembourrage symétrique

Le remplissage symétrique est une technique de manipulation de tableaux qui permet de maintenir une extension équilibrée et naturelle des données d’origine. Il est similaire au remplissage réfléchissant, mais il inclut les valeurs de bord elles-mêmes dans la réflexion. Cette méthode est utile pour maintenir la symétrie dans le tableau rembourré.

Exemple :

array = np.array([[1, 2], [3, 4]])

padded_array = np.pad(array, pad_width=1, mode="symmetric")

print(padded_array)

Sortie :

[[1 1 2 2]

[1 1 2 2]

[3
Source