Diffusion numpy

Des tableaux de différentes tailles ne peuvent pas être ajoutés, soustraits ou autrement utilisés en arithmétique. Duplication du tableau de petit pour lui donner les mêmes dimensions et taille que le plus grand tableau est une approche. Lors de l'arithmétique du tableau, Numpy propose une fonctionnalité connue sous le nom de diffusion de tableau qui peut considérablement raccourcir et simplifier votre code. Vous découvrirez l'idée de la diffusion de tableaux et comment l'utiliser dans Numpy dans ce tutoriel. De plus, plusieurs exemples de programmes sont fournis.

Qu'est-ce que la diffusion Numpy?

Lors de l'exécution d'opérations arithmétiques sur des tableaux de différentes formes, Numpy fait référence à cela de la diffusion. Ces opérations de tableau sont fréquemment effectuées sur les éléments respectifs. Si deux tableaux ont la même forme, cela peut être fait sur eux avec facilité. Même si ce concept est utile, la diffusion n'est pas toujours recommandée car elle peut entraîner une utilisation inefficace de la mémoire qui ralentit le calcul. Les opérations Numpy sont souvent effectuées sur des paires de tableaux qui sont décomposées élément par élément.

Règles de diffusion

Un ensemble particulier de directives doit être suivi lors de la diffusion. Ceux-ci sont décrits ci-dessous:

1. La forme du réseau de rang inférieur est importante pour être apparente avec 1.
2. Deux tableaux sont considérés comme compatibles s'ils ont la même taille de dimension ou si l'un d'eux a la taille de dimension réglée sur 1.
3. Les tableaux ne peuvent être diffusés ensemble que si leurs tailles et leurs dimensions correspondent.
4. Une fois la radiodiffusion terminée, chaque tableau agit comme si sa forme correspondait à celle du plus grand élément des formes des deux tableaux d'entrée.
5. L'un des tableaux se comporte comme s'il était reproduit avec cette dimension si l'autre tableau a une dimension supérieure à 1 et que le premier tableau a une dimension de 1.

Maintenant, discutons de quelques exemples de mise en œuvre du concept de diffusion.

Exemple 1:

Sur les paires de tableaux, les opérations Numpy sont généralement effectuées élément par éléments. Les deux tableaux doivent, dans le scénario le plus simple, avoir la même forme, comme dans l'exemple ci-dessous:

Importer Numpy
one_arr = Numpy.Array ([2.0, 3.0, 1.0])
Two_arr = Numpy.Array ([3.0, 3.0, 3.0])
imprimer (one_arr * deux_arr)

Comme vous pouvez le voir sur le code ci-dessus, nous avons deux tableaux: 'One_Ar' et 'Two_ Arr'. Chacun ayant un ensemble distinct de valeurs. Les valeurs dans «one_arr» sont [2.0,3.0,1.0] et «deux _arr» sont [3.0,3.0,3.0]. Vous pouvez alors voir que le résultat du calcul du produit de ces deux tableaux est le suivant:

Lorsque certaines exigences sont satisfaites par les formulaires des tableaux, la règle de diffusion de Numpy réduit cette restriction. Lorsqu'un tableau et une valeur scalaire sont rejoints dans une opération, la diffusion est démontrée dans sa forme la plus élémentaire. Comme vous pouvez le voir, 3 est contenu dans la variable nommée 'Two_Ar.'

Importer Numpy
one_arr = Numpy.Array ([2.0, 3.0, 1.0])
deux_arr = 3.0
imprimer (one_arr * deux_arr)

Le code ci-dessus produit le résultat suivant.

Dans l'exemple précédent, où 'Two_arr' était un tableau, le résultat est équivalent. Nous pouvons imaginer le scalaire «Two_arr» élargi pendant le processus arithmétique dans un tableau ayant la même forme que «un _arr.'The Array' Two_arr 'contient de nouveaux éléments qui ne sont que des doublons du premier scalaire. La comparaison d'étirement est simplement hypothétique. Pour rendre les opérations de radiodiffusion comme mémoire et économique sur le plan de calcul que possible, Numpy est suffisamment intelligent pour utiliser la valeur scalaire d'origine plutôt que de produire des copies.

Exemple 2:

Voici un autre programme Python simple qui effectue la diffusion. Encore une fois, deux tableaux sont créés contenant des valeurs différentes. Il est nécessaire de remodeler 'first_arr' dans un vecteur de colonne avec une forme 3 × 1 pour calculer un produit extérieur. Après cela, la diffusion est effectuée contre 'second_arr' pour fournir le résultat de la taille 3 × 2, connue sous le nom de produit extérieur de 'First_arr' et 'Second_Ar.«La diffusion à 2 × 3 est possible puisque« result_arr »a la forme 2 × 3 ainsi que la forme (3,).

Après avoir suivi toutes les étapes susmentionnées, un vecteur doit être inclus dans chaque colonne des matrices qui sont `` result_arr 'et' second_arr.'Ceux-ci ont des dimensions de 2 × 3 et (2,). La transformation «result_arr» produira une forme de 3 × 2, qui peut ensuite être diffusée contre «second_arr» pour obtenir le même formulaire. En règle générale, la transformation de ceci donne un produit final dans la forme 2 × 3.

Importer Numpy
first_arr = numpy.Array ([12, 24, 14])
second_arr = numpy.Array ([15, 22])
Imprimer (Numpy.Reshape (premier_arr, (3, 1)) * second_arr)
result_arr = numpy.Array ([[12, 22, 31], [15, 22, 45]]))
print (result_arr + first_arr)
imprimer ((result_arr.T + second_arr).T)
Imprimer (result_arr + numpy.Reshape (second_arr, (2, 1)))
print (result_arr * 2)

Vous pouvez afficher la sortie ci-dessous.

Exemple 3:

Un tableau tridimensionnel peut être diffusé à l'aide du programme Python suivant. Dans cet exemple, deux tableaux nommés 'First_arr' et 'Second_Ar' ont été générés. Le tableau «first_arr» contient [4,13,26,12] valeurs et «second_arr» contient [32,67,45,17]. Les 2 dimensions du tableau initial font la différence. La somme du premier et du deuxième tableau sera présentée ci-dessous après l'exécution du code. Vous pouvez voir que nous avons trois instructions d'impression dans le code, chacune affiche le texte 'First Array:', 'Second Array' et 'Third Array:' À son tour. La somme de ces deux tableaux nouvellement générés est alors indiqué.

Importer Numpy
first_arr = numpy.Array ([[4, 13, 26, 12], [32, 67, 45, 17]])
second_arr = numpy.Array ([24,45,66,87])
print ("\ n Premier tableau:")
imprimer (first_arr)
print ("\ n Deuxième tableau:")
imprimer (second_arr)
Print ("\ nsum du premier et deuxième tableau:")
sum_result = first_arr + second_arr;
imprimer (sum_result)

Voici la capture d'écran de sortie du code donné.

Exemple 4:

Le dernier programme Python qui diffuse un tableau tridimensionnel est donné ici. Deux tableaux sont spécifiés dans ce programme, dont le premier a trois dimensions. La somme du premier et du deuxième tableau sera affichée comme indiqué ci-dessus après l'exécution du code. Bien que les valeurs de ces tableaux varient, le code restant est le même que celui utilisé dans l'exemple de programme ci-dessus.

Importer Numpy
first_arr = numpy.Array ([[12, 45, 22, 13], [22, 54, 25, 12], [50, 40, 18, 26]]))
second_arr = numpy.Array ([12,44,22,12])
print ("\ n Premier tableau:")
imprimer (first_arr)
print ("\ n Deuxième tableau:")
imprimer (second_arr)
Print ("\ nsum du premier et deuxième tableau:")
sum_result = first_arr + second_arr;
imprimer (sum_result)

Vous pouvez voir dans la figure ci-dessous qu'un tableau tridimensionnel du premier tableau est présenté, suivi d'un tableau en 2 dimensions du deuxième tableau et du résultat de ces deux-là en utilisant le principe de diffusion.

Conclusion

Cet article a discuté de la diffusion, un concept de python crucial. Dans Numpy, le terme «diffusion» fait référence à la capacité de gérer les tableaux de différentes formes tout en effectuant des opérations arithmétiques qui sont fréquemment effectuées. Le sujet susmentionné a été soigneusement couvert de divers exemples. Cet article a utilisé les exemples de programmes mentionnés pour démontrer comment diffuser sur les tableaux 1-D, 2D et 3D, respectivement. Vous pouvez essayer d'exécuter ces exemples sur votre système et afficher les résultats pour mieux comprendre comment tout fonctionne en général.