technique non basique de numpy

Le [Tutoriel de démarrage rapide] de numpy (https://numpy.org/doc/stable/user/quickstart.html) a une technique moins basique (pas très basique), donc j'ai pensé que ce serait intéressant, donc je vais l'introduire tout en comprenant.

Index d'un tableau utilisant un tableau

L'index d'un tableau (la partie i dans a [i]) a généralement une valeur scalaire, mais vous pouvez également placer le tableau ici.

import numpy as np

a = np.arange(12)**2                       
i = np.array([1, 1, 3, 8, 5])             
a[i] #array([ 1,  1,  9, 64, 25], dtype=int32)

Ce qui se passe est comme indiqué sur la figure.

Est-ce une image que l'élément du tableau i devient un index et est extrait du tableau d'un l'utilisant?

L'index peut également être appliqué à un tableau à deux dimensions. Dans ce cas, la sortie sera également bidimensionnelle.

j = np.array([[3, 6, 7], [5, 9, 7]])      
a[j]                                       
#array([[ 9, 36, 49],
#       [25, 81, 49]], dtype=int32)

Dans le didacticiel, RVB est donné comme exemple d'application, mais il semble qu'il puisse également être utilisé pour une expression one-hot utilisée dans l'apprentissage automatique.

one_hot = np.array([[0, 0, 0], 
                    [1, 0, 0], 
                    [0, 1, 0],      
                    [0, 0, 1]])
number = np.array([[0, 1, 2, 0], 
                  [0, 3, 2, 0]])
one_hot[number]
#array([[[0, 0, 0],
#        [1, 0, 0],
#        [0, 1, 0],
#        [0, 0, 0]],
#
#       [[0, 0, 0],
#        [0, 0, 1],
#        [0, 1, 0],
#        [0, 0, 0]]])

Au fait, notez que même si vous définissez `number [one_hot [number]]` `, il ne sera pas restauré.

Vous pouvez également spécifier plusieurs tableaux pour l'index.

a = np.arange(12).reshape(3,4)
#array([[ 0,  1,  2,  3],
#       [ 4,  5,  6,  7],
#       [ 8,  9, 10, 11]])
i = np.array([[0, 1],                     
              [1, 2]])
j = np.array([[2, 1],                     
              [3, 3]])
a[i, j] 
#array([[ 2,  5],
#      [ 7, 11]])

Il est difficile d'interpréter comment cela est géré, mais c'est comme suit.

Vous pouvez également spécifier une liste comme index du tableau.

a = np.arange(3,8)
a
#array([3, 4, 5, 6, 7])
a[[1,3,4]] = 0
a
#array([3, 0, 5, 0, 0])

Là encore, chaque élément de la liste est traité comme un index de a.

Vous pouvez utiliser la liste pour attribuer (attribuer) tous à la fois, mais s'il y a les mêmes numéros dans la liste, l'assignation sera répétée et la dernière valeur sera assignée.

a = np.arange(3,8)
a
#array([3, 4, 5, 6, 7])
a[[1,1,4]] = [1,2,3]
a
#array([3, 2, 5, 6, 3])

Indexation à l'aide d'un tableau booléen

Vous pouvez créer un tableau booléen en donnant au tableau un opérateur logique.

En utilisant un tableau booléen comme index, un tableau unidimensionnel avec les éléments False supprimés est généré (notez la forme du tableau).

a = np.arange(-3,9).reshape(3,4)
a
#array([[-3, -2, -1,  0],
#       [ 1,  2,  3,  4],
#       [ 5,  6,  7,  8]])
b = a > 0
b                                   
#array([[False, False, False, False],
#       [ True,  True,  True,  True],
#       [ True,  True,  True,  True]])
a[b]                                       
#array([1, 2, 3, 4, 5, 6, 7, 8])

En affectant un tableau booléen à un tableau indexé, vous pouvez affecter les éléments qui remplissent les conditions à la fois.

a[a<0] = 0                                  
a
#array([[0, 0, 0, 0],
#       [1, 2, 3, 4],
#       [5, 6, 7, 8]])

Des extractions plus complexes sont possibles en utilisant le même tableau booléen que les dimensions (axe).

a = np.arange(12).reshape(3,4)
b1 = np.array([False,True,True])             
b2 = np.array([True,False,True,False])     

a[b1,:] #a[b1]Mais oui
#array([[ 4,  5,  6,  7],
#       [ 8,  9, 10, 11]])

a[:,b2] #a[b2]Mais oui
#array([[ 0,  2],
#       [ 4,  6],
#       [ 8, 10]])

a[b1,b2]                                 
#array([ 4, 10])

En regardant la figure, cela ressemble à ceci.

Je me demande pourquoi a [b1, b2] est [4,10] au lieu de [[4,6], [8,10]]. La documentation dit aussi une chose étrange à faire, alors je me demande si je dois m'en souvenir.

Résumé

Jusqu'à présent, nous avons introduit l'indexation des tableaux à l'aide de tableaux et l'indexation des tableaux booléens. C'est une technique délicate, mais elle devrait être utile si vous la maîtrisez.

Le tutoriel avec le lien au début a d'autres techniques (je l'ai omis car je ne pouvais pas bien le comprendre), donc si vous pouvez vous le permettre, veuillez le lire.