Comment numpy.newaxis fonctionne-t-il et quand l'utiliser?
Quand j'essaye
_numpy.newaxis
_le résultat me donne un cadre graphique en 2D avec un axe des abscisses compris entre 0 et 1. Cependant, lorsque j'essaie d'utiliser _numpy.newaxis_ pour découper un vecteur,
_vector[0:4,]
[ 0.04965172 0.04979645 0.04994022 0.05008303]
vector[:, np.newaxis][0:4,]
[[ 0.04965172]
[ 0.04979645]
[ 0.04994022]
[ 0.05008303]]
_Est-ce la même chose sauf que cela change un vecteur de ligne en un vecteur de colonne?
De manière générale, à quoi sert numpy.newaxis , et dans quelles circonstances devrions-nous l’utiliser?
Autrement dit, le newaxis est utilisé pour augmenter la dimension du tableau existant par une autre dimension , lorsqu’elle est utilisée une fois . Ainsi,
1D tableau deviendra tableau 2D
Le tableau 2D devient le tableau 3D
Le tableau 3D devient le tableau 4D
Le tableau 4D devient le tableau 5D
etc..
Voici une illustration visuelle qui décrit la promotion d’un tableau 1D vers des tableaux 2D.
Scénario 1 : np.newaxis == peut être utile lorsque vous souhaitez explicitement convertit un tableau 1D en vecteur de ligne ou en vecteur de colonne , comme illustré dans l'image ci-dessus.
Exemple:
_# 1D array
In [7]: arr = np.arange(4)
In [8]: arr.shape
Out[8]: (4,)
# make it as row vector by inserting an axis along first dimension
In [9]: row_vec = arr[np.newaxis, :] # arr[None, :]
In [10]: row_vec.shape
Out[10]: (1, 4)
# make it as column vector by inserting an axis along second dimension
In [11]: col_vec = arr[:, np.newaxis] # arr[:, None]
In [12]: col_vec.shape
Out[12]: (4, 1)
_Scénario 2 : Lorsque nous voulons utiliser numpy broadcast dans le cadre de certaines opérations, pour instance en faisant addition de certains tableaux.
Exemple:
Supposons que vous souhaitiez ajouter les deux tableaux suivants:
_ x1 = np.array([1, 2, 3, 4, 5])
x2 = np.array([5, 4, 3])
_Si vous essayez de les ajouter comme cela, NumPy lèvera le ValueError suivant:
_ValueError: operands could not be broadcast together with shapes (5,) (3,)
_Dans cette situation, vous pouvez utiliser np.newaxis pour augmenter la dimension de l'un des tableaux afin que NumPy puisse broadcast .
_In [2]: x1_new = x1[:, np.newaxis] # x1[:, None]
# now, the shape of x1_new is (5, 1)
# array([[1],
# [2],
# [3],
# [4],
# [5]])
_Maintenant, ajoutez:
_In [3]: x1_new + x2
Out[3]:
array([[ 6, 5, 4],
[ 7, 6, 5],
[ 8, 7, 6],
[ 9, 8, 7],
[10, 9, 8]])
_Vous pouvez également ajouter un nouvel axe au tableau _x2_:
_In [6]: x2_new = x2[:, np.newaxis] # x2[:, None]
In [7]: x2_new # shape is (3, 1)
Out[7]:
array([[5],
[4],
[3]])
_Maintenant, ajoutez:
_In [8]: x1 + x2_new
Out[8]:
array([[ 6, 7, 8, 9, 10],
[ 5, 6, 7, 8, 9],
[ 4, 5, 6, 7, 8]])
_Remarque : Remarquez que nous obtenons le même résultat dans les deux cas (l'un étant la transposition de l'autre).
Scénario 3 : Ceci est similaire au scénario 1. Mais, vous pouvez utiliser np.newaxis plus d'une fois pour promouvoir le tableau en dimensions supérieures. Une telle opération est parfois nécessaire pour les tableaux d'ordre supérieur (, à savoir les tenseurs ).
Exemple:
_In [124]: arr = np.arange(5*5).reshape(5,5)
In [125]: arr.shape
Out[125]: (5, 5)
# promoting 2D array to a 5D array
In [126]: arr_5D = arr[np.newaxis, ..., np.newaxis, np.newaxis] # arr[None, ..., None, None]
In [127]: arr_5D.shape
Out[127]: (1, 5, 5, 1, 1)
_Plus d'informations sur np.newaxis vs np.reshape
newaxis est également appelé pseudo-index qui permet l'ajout temporaire d'un axe dans un multi-tableau.
np.newaxis == utilise l'opérateur de découpage pour recréer le tableau alors que np.reshape remodèle le tableau à la présentation souhaitée. (en supposant que les dimensions correspondent; et ceci est doit pour un reshape arriver).
Exemple
_In [13]: A = np.ones((3,4,5,6))
In [14]: B = np.ones((4,6))
In [15]: (A + B[:, np.newaxis, :]).shape # B[:, None, :]
Out[15]: (3, 4, 5, 6)
_Dans l'exemple ci-dessus, nous avons inséré un axe temporaire entre les premier et deuxième axes de B (utiliser la diffusion). Un axe manquant est rempli ici en utilisant np.newaxis pour que l'opération broadcast .
Astuce générale : Vous pouvez également utiliser None à la place de np.newaxis ; Ce sont en fait les mêmes objets .
_In [13]: np.newaxis is None
Out[13]: True
_P.S. Voir aussi cette excellente réponse: newaxis vs reshape pour ajouter des dimensions
Qu'est-ce que _np.newaxis_?
Le _np.newaxis_ est simplement un alias pour le Python constant None, ce qui signifie que partout où vous utilisez _np.newaxis_, vous pouvez également utiliser None:
_>>> np.newaxis is None
True
_C’est juste plus descriptif si vous lisez du code qui utilise _np.newaxis_ au lieu de None.
Comment utiliser _np.newaxis_?
Le _np.newaxis_ est généralement utilisé avec le découpage en tranches. Cela indique que vous souhaitez ajouter une dimension supplémentaire au tableau. La position de _np.newaxis_ représente l'endroit où je veux ajouter des dimensions.
_>>> import numpy as np
>>> a = np.arange(10)
>>> a
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> a.shape
(10,)
_Dans le premier exemple, j'utilise tous les éléments de la première dimension et ajoute une seconde:
_>>> a[:, np.newaxis]
array([[0],
[1],
[2],
[3],
[4],
[5],
[6],
[7],
[8],
[9]])
>>> a[:, np.newaxis].shape
(10, 1)
_Le deuxième exemple ajoute une dimension en tant que première dimension et utilise ensuite tous les éléments de la première dimension du tableau d'origine en tant qu'éléments de la deuxième dimension du tableau de résultats:
_>>> a[np.newaxis, :] # The output has 2 [] pairs!
array([[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]])
>>> a[np.newaxis, :].shape
(1, 10)
_De même, vous pouvez utiliser plusieurs _np.newaxis_ pour ajouter plusieurs dimensions:
_>>> a[np.newaxis, :, np.newaxis] # note the 3 [] pairs in the output
array([[[0],
[1],
[2],
[3],
[4],
[5],
[6],
[7],
[8],
[9]]])
>>> a[np.newaxis, :, np.newaxis].shape
(1, 10, 1)
_Existe-t-il des alternatives à _np.newaxis_?
Il existe une autre fonctionnalité très similaire dans NumPy: np.expand_dims , qui peut également être utilisée pour insérer une dimension:
_>>> np.expand_dims(a, 1) # like a[:, np.newaxis]
>>> np.expand_dims(a, 0) # like a[np.newaxis, :]
_Mais étant donné que cela insère simplement _1_ s dans le shape, vous pouvez également reshape le tableau pour ajouter ces dimensions:
_>>> a.reshape(a.shape + (1,)) # like a[:, np.newaxis]
>>> a.reshape((1,) + a.shape) # like a[np.newaxis, :]
_La plupart du temps, _np.newaxis_ est le moyen le plus simple d’ajouter des dimensions, mais il est bon de connaître les alternatives.
Quand utiliser _np.newaxis_?
L'ajout de dimensions est utile dans plusieurs contextes:
Si les données doivent avoir un nombre spécifié de dimensions. Par exemple, si vous souhaitez utiliser _
matplotlib.pyplot.imshow_ pour afficher un tableau 1D.Si vous voulez que NumPy diffuse des tableaux. En ajoutant une dimension, vous pouvez par exemple obtenir la différence entre tous les éléments d'un tableau: _
a - a[:, np.newaxis]_. Cela fonctionne car les opérations NumPy sont diffusées à partir de la dernière dimension. 1.Pour ajouter une dimension nécessaire afin que NumPy puisse diffuser des tableaux. Cela fonctionne car chaque dimension de longueur 1 est simplement diffusée à la longueur de la longueur correspondante.1 dimension de l'autre tableau.
1 Si vous voulez en savoir plus sur les règles de diffusion, le documentation de NumPy sur ce sujet est très bon. Il comprend également un exemple avec _np.newaxis_:
_>>> a = np.array([0.0, 10.0, 20.0, 30.0]) >>> b = np.array([1.0, 2.0, 3.0]) >>> a[:, np.newaxis] + b array([[ 1., 2., 3.], [ 11., 12., 13.], [ 21., 22., 23.], [ 31., 32., 33.]])_
Vous avez commencé avec une liste de nombres unidimensionnelle. Une fois que vous avez utilisé numpy.newaxis, vous l'avez transformé en une matrice à deux dimensions, composée de quatre lignes d'une colonne chacune.
Vous pouvez ensuite utiliser cette matrice pour la multiplication matricielle ou l'impliquer dans la construction d'une matrice 4 x n plus grande.
newaxis objet dans la sélection Le nuplet sert à étendre les dimensions de la sélection résultante de ne unité de longueur dimension.
Il ne s’agit pas simplement de convertir une matrice de lignes en une matrice de colonnes.
Considérons l'exemple ci-dessous:
In [1]:x1 = np.arange(1,10).reshape(3,3)
print(x1)
Out[1]: array([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])
Ajoutons maintenant une nouvelle dimension à nos données,
In [2]:x1_new = x1[:,np.newaxis]
print(x1_new)
Out[2]:array([[[1, 2, 3]],
[[4, 5, 6]],
[[7, 8, 9]]])
Vous pouvez voir que newaxis a ajouté la dimension supplémentaire ici, x1 a la dimension (3,3) et X1_nouveau a la dimension (3,1,3).
Comment notre nouvelle dimension nous permet d’effectuer différentes opérations:
In [3]:x2 = np.arange(11,20).reshape(3,3)
print(x2)
Out[3]:array([[11, 12, 13],
[14, 15, 16],
[17, 18, 19]])
En ajoutant x1_new et x2, nous obtenons:
In [4]:x1_new+x2
Out[4]:array([[[12, 14, 16],
[15, 17, 19],
[18, 20, 22]],
[[15, 17, 19],
[18, 20, 22],
[21, 23, 25]],
[[18, 20, 22],
[21, 23, 25],
[24, 26, 28]]])
Ainsi, newaxis ne consiste pas simplement en une conversion de matrice en colonnes. Cela augmente la dimension de la matrice, nous permettant ainsi de faire plus d'opérations dessus.