Améliorer l'efficacité mathématique : naviguer dans les opérations de tableau Numpy

Recommandation : utilisez l'éditeur de scène NSDT pour créer rapidement des scènes d'application 3D

Qu’est-ce que Numpy ?

Numpy, Scipy et Matplotlib sont des bibliothèques Python utilisées dans des projets de science des données qui fournissent des fonctionnalités de type MATLAB.

Image de Wikipédia

Principalement, Numpy a les fonctionnalités suivantes :

1. Tableau multidimensionnel typé (matrice)
2. Calculs numériques rapides (mathématiques matricielles)
3. Fonctions mathématiques avancées

Numpy signifie Numerical Python et est un progiciel essentiel requis pour le calcul haute performance et l'analyse de données. NumPy est nécessaire pour les calculs numériques en Python car il est conçu pour être efficace avec de grands tableaux de données.

Différentes façons de créer des tableaux numpy

Avant de commencer à opérer sur des tableaux numpy, notre premier objectif est de devenir compétent dans la création de tableaux numpy selon nos exigences basées sur l'énoncé du problème.

Il existe plusieurs façons de créer des tableaux numpy. Certaines méthodes standards et pratiques sont mentionnées ci-dessous :

Cas 1 : créez un tableau à l'aide de la méthode np.ones :

Si nous devons créer un tableau avec seulement des "un", vous pouvez utiliser cette méthode.

np.ones((3,5), dtype=np.float32)
#Output
[[1. 1. 1. 1. 1.]
 [1. 1. 1. 1. 1.]

Cas 2 : créez un tableau de zéros à l'aide de la méthode np.zeros :

Si nous devons créer un tableau avec uniquement des "zéros", vous pouvez utiliser cette méthode.

np.zeros((6,2), dtype=np.int8)
# Output
[[0 0]
 [0 0]
 [0 0]
 [0 0]
 [0 0]
 [0 0]]

Cas 3 : Utilisation de la méthode np.arange :

Vous pouvez utiliser cette méthode si vous devez créer un tableau d’éléments en séquence.

np.arange(1334,1338)
#Output
[1334 1335 1336 1337]

Cas 4 : Utilisation de la méthode np.concatenate :

Cette approche est correcte lorsque le tableau souhaité combine un ou plusieurs tableaux.

A = np.ones((2,3))
B = np.zeros((4,3))
C = np.concatenate([A, B])
#Output
[[1. 1. 1.]
 [1. 1. 1.]
 [0. 0. 0.]
 [0. 0. 0.]
 [0. 0. 0.]
 [0. 0. 0.]]

Cas 5 : Utilisation de la méthode np.random.random :

Ceci est utile lors de la création de tableaux avec des valeurs aléatoires.

np.random.random((2,3))
#Output
[[0.30512345 0.10055724 0.89505387]
 [0.36219316 0.593805   0.7643694 ]]

Opérations sur les tableaux Numpy

Discutons des propriétés de base des tableaux numpy avec un exemple :

code:

a = numpy.array([[1,2,3],[4,5,6]],dtype=numpy.float32)
# Array dimensions, shape, and data types
print (a.ndim, a.shape, a.dtype)
Output:
2 (2, 3) float32

Sur la base du code ci-dessus, nous avons les points suivants à retenir en conclusion :

1. Les tableaux peuvent avoir n'importe quelle dimension sous forme d'entier positif, y compris zéro (correspondant à des valeurs scalaires).
2. Les tableaux sont typés et peuvent avoir des types de données tels que np.uint8, np.int64, np.float32, np.float64
3. Les tableaux sont denses. Chaque élément du tableau existe et a le même type.

code:

# Arrays reshaping
a = numpy.array([1,2,3,4,5,6])
a = a.reshape(3,2)              
#Output: 
[[1 2]                 
[3 4]                           
[5 6]]

a = a.reshape(2,-1)
#Output: 
[[1 2 3]
 [4 5 6]]

a = a.ravel()
#Output:  
[1 2 3 4 5 6]

Points clés à retenir :

1. Après l'opération de remodelage, le nombre total d'éléments du tableau ne peut plus être modifié.
2. Pour déduire la forme de l’axe, utilisez -1.
3. Par défaut, il stocke les éléments au format ligne principale, tandis que dans MATLAB, il s'agit du format colonne principale.

diffusion numérique

La diffusion permet d'effectuer des opérations sur des réseaux de formes différentes à condition qu'elles soient compatibles. Les dimensions les plus petites du tableau s'étendent en fait pour correspondre aux dimensions du tableau plus grand.

Photo de Javatpoint

code:

# arrays broadcasting
a = numpy.array([[1, 2], [3, 4], [5, 6]])
b = numpy.array([10, 20])
c = a + b  # Broadcasting the 'b' array to match the dimensions of 'a'

L'exemple implique un tableau NumPy 2D "a" de dimensions (2, 3) et un tableau 1D "b" de forme (1). La diffusion permet à l'opération « a + b » d'étendre virtuellement « b » pour correspondre à « a » en deux dimensions, effectuant ainsi une addition élément par élément entre « a » et le « b » étendu.

Indexation et découpage de tableaux

1. Les tranches sont des vues. L'écriture dans une tranche écrase le tableau d'origine.
2. Des listes ou des tableaux booléens peuvent également être indexés.
3. Syntaxe de l'index Python :

start_index ： stop_index： step_size

code:

a = list(range(10)) 

 # first 3 elements
a[:3] # indices 0, 1, 2 

# last 3 elements
a[-3:] # indices 7, 8, 9 

# indices 3, 5, 7 
a[3:8:2] 

# indices 4, 3, 2 (this one is tricky)
a[4:1:-1] 

Comme vous le savez, les images peuvent également être visualisées sous forme de tableaux multidimensionnels. Le découpage permet donc également d'effectuer certaines opérations mathématiques sur l'image. Quelques exemples importants et avancés sont mentionnés ci-dessous pour améliorer votre compréhension :

# Select all but one-pixel border 
pixel_matrix[1:-1,1:-1] 		

# swap channel order 
pixel_matrix = pixel_matrix[:,:,::-1]

# Set dark pixels to black 	
pixel_matrix[pixel_matrix<10] = 0

# select 2nd and 4th-row		
pixel_matrix[[1,3], :]	

Agrégation et réduction de tableaux

Maintenant, nous allons commencer par les opérations d'agrégation sur les tableaux numpy. En règle générale, voici ce que vous pouvez faire :

1. Trouvez la somme et le produit de tous les éléments d'un tableau.
2. Trouver les éléments maximum et minimum dans un tableau
3. Trouver le nombre d'un élément spécifique dans un tableau
4. Nous pouvons également utiliser le module Algèbre Linéaire pour trouver d'autres paramètres, notamment les déterminants matriciels, les traces matricielles, les valeurs propres et vecteurs propres matriciels, etc.

Commençons par discuter de chaque fonctionnalité avec un exemple :

Cas 1 : somme algébrique de tous les éléments présents dans un tableau

array_1 = numpy.array([[1,2,3], [4,5,6]])
print(array_1.sum())
#Output: 
21

Cas 2 : élément maximum dans le tableau

array_1 = numpy.array([[1,2,3], [4,5,6]])
print(array_1.max())
#Output: 
6

Cas 3 : élément minimum dans le tableau

array_1 = numpy.array([[1,2,3], [4,5,6]])
print(array_1.min())
#Output: 
1

Cas 4 : Position/index de l'élément où se trouve le plus grand élément du tableau

array_1 = numpy.array([[1,2,3], [4,5,6]])
print(array_1.argmax())
#Output: 
5

Cas 5 : Position/index de l'élément où se trouve le plus petit élément du tableau

array_1 = numpy.array([[1,2,3], [4,5,6]])
print(array_1.argmin())
#Output: 
0

En recherchant l'emplacement, vous pouvez observer qu'il traite tout tableau multidimensionnel comme un tableau unidimensionnel, puis effectue des calculs dessus.

Cas 6 : Moyenne/moyenne de tous les éléments d'un tableau

array_1 = numpy.array([[1,2,3], [4,5,6]])
print(array_1.mean())
#Output: 
3.5

Cas 7 : Produit scalaire/produit scalaire de tableaux bidimensionnels

array_1 = numpy.array([[1,2], [4,5]])
array_2 = numpy.array([[1,-1,2], [3,7,-2]])
t = array_1.dot(array_2)
print(t)
#Output: 
[[ 7 13 -2]
 [19 31 -2]]

Vectorisation dans des tableaux numériques

La vectorisation permet d'effectuer des opérations sur l'ensemble du tableau plutôt que d'itérer sur des éléments individuels. Il exploite des routines de bas niveau optimisées, ce qui permet d'obtenir un code plus rapide et plus propre.

code:

a = numpy.array([1, 2, 3, 4, 5])
b = numpy.array([10, 20, 30, 40, 50])
c = a + b  # Element-wise addition without explicit loops

Sur la base de l'exemple ci-dessus, vous pouvez voir que deux tableaux NumPy nommés « a » et « b » sont créés. Lors de l'exécution de l'opération « a + b », nous utilisons le concept de vectorisation pour effectuer une addition élément par élément entre les tableaux, ce qui donne un nouveau tableau « c » contenant la somme des éléments correspondants de « a » et « b ». Par conséquent, le programme évite d'exécuter des boucles explicites en raison d'opérations par éléments et utilise des routines optimisées pour des calculs efficaces.

Concaténation de tableaux

Cas 1 : Supposons que vous ayez deux tableaux ou plus à concaténer à l’aide de la fonction concaténer, où vous devez concaténer des tuples de tableaux.

code:

# concatenate 2 or more arrays using concatenate function row-wise
numpy_array_1 = numpy.array([1,2,3])
numpy_array_2 = numpy.array([4,5,6])
numpy_array_3 = numpy.array([7,8,9])
array_concatenate = numpy.concatenate((numpy_array_1, numpy_array_2, numpy_array_3))
print(array_concatenate)
#Output:
[1 2 3 4 5 6 7 8 9]

Cas 2 : Supposons que vous ayez un tableau à plusieurs dimensions ; alors, pour joindre les tableaux, vous devez mentionner l'axe sur lequel ces tableaux doivent être joints. Sinon, il sera exécuté selon la première dimension.

code:

# concatenate 2 or more arrays using concatenate function column-wise
array_1 = numpy.array([[1,2,3], [4,5,6]])
array_2 = numpy.array([[7,8,9], [10, 11, 12]])
array_concatenate = numpy.concatenate((array_1, array_2), axis=1)
print(array_concatenate)
#Output:
[[ 1  2  3  7  8  9]
 [ 4  5  6 10 11 12]]

Fonctions mathématiques et fonctions générales

Ces fonctions universelles sont également appelées ufuncs. Des opérations par éléments sont effectuées dans ces fonctions. Par exemple:

1. NP.exp
2. NP.sqrt
3. Xinxian
4. NP.cos
5. np. isnan

code:

A = np.array([1,4,9,16,25])
B = np.sqrt(A)
#Output
[1. 2. 3. 4. 5.]

Comparaison des performances

Lors de l'exécution de calculs numériques, Python prend beaucoup de temps si nous avons un grand nombre de calculs. Si nous prenons une matrice de forme 1000 x 1000 et effectuons une multiplication matricielle, le temps requis en Python et numpy est :

1. La triple boucle Python prend> 10 minutes
2. Le numérique prend environ 0,03 seconde

Ainsi, à partir de l'exemple ci-dessus, nous pouvons voir que numpy prend beaucoup moins de temps que Python standard et que notre latence est donc réduite dans des situations réelles liées à la science des données où il y a une énorme quantité de données à traiter.

conclure

Dans cet article, nous avons discuté des tableaux numpy. Alors, pour terminer notre session, résumons les avantages de numpy par rapport à Python :

1. Numpy propose des calculs orientés tableau.
2. Numpy implémente efficacement des tableaux multidimensionnels.
3. Numpy est principalement conçu pour le calcul scientifique.
4. Numpy contient des fonctions mathématiques standard pour des calculs plus rapides sur des tableaux sans boucles.
5. Numpy possède des modules intégrés d'algèbre linéaire et de génération de nombres aléatoires qui peuvent utiliser les fonctions de transformation de Fourier.
6. Numpy comprend également des outils pour lire et écrire des tableaux sur le disque et travailler avec des fichiers mappés en mémoire.

Lien d'origine : Améliorer l'efficacité mathématique : navigation dans les opérations de tableau Numpy (mvrlink.com)