Discussion :

[MagicJohnson]

Bonjour,

Je me heurte à une difficulté qui, à mon niveau, me pose problème.

J'ai un tableau NumPy de forme (2, 10920).

Pour les besoins de mon explication, j'ai limité le nombre de colonnes à 20 soit de 0 à 19 inclus:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
[[0.4625 0.6856 0.7016 0.4912 0.7537 0.768  0.5193 0.7622 0.4744 0.4632  0.     0.7486 0.4844 0.6658 0.7615 0.4686 0.     0.     0.     0.    ]
 [1.     1.     0.     0.     1.     1.     0.     0.     0.     0.   0.     1.     0.     0.     0.     0.     0.     0.     0.     0.    ]]

Mes colonnes sont en réalité la juxtaposition de résultats regroupés par 20; 10920 est donc un multiple de 20.
En ligne 0, nous avons des chiffres diverses type float.
En ligne 1, nous ne trouverons que des float de valeur 1.0 ou 0.0 qui, parmi les paquets de 20 colonnes, ne peuvent contenir que 5 fois la valeur 1.0 .


Ce que je cherche à effectuer, c'est, parmi ces paquets de 20 colonnes, identifier sur la ligne 0 les 8 valeurs les plus élevées (en cas d'égalité sur les dernières colonnes retenues celles dont l'index est le plus faible) et une fois qu'elles sont identifiées - ce qui constitue en réalité le but poursuivi - déterminer le nombre de ces paquets de 8 colonnes les plus élevées en ligne 0 celles qui contiennent en ligne 1 les 5 valeurs 1.0 .

Au final ce que je souhaite, c'est réduire les ensembles de 20 colonnes en des ensembles de 8 colonnes constituées des plus grandes valeurs du rang 0 et ensuite déterminer parmi ces nouveaux ensembles de 8 colonnes, le nombre de fois où ces paquets de 8 colonnes contiennent au range 1 les 5 float 1.0.

Je me suis dit que NumPy pouvait être un bon outil pour effectuer cette recherche au plus vite car cette démarche va être effectuée sur de grandes quantités de situations.

Si quelqu'un aurait un piste, ce serait sympa. Merci d'avance en tout cas.

[wiztricks]

Salut,

Plutôt que de prendre de si grands nombres qui rendent difficiles l'exposé de ce que vous voulez faire, prenez un exemple plus petit et reformulez le problème en fonction de variables M, N,... (puisque leur valeurs "petites" sont juste pour l'exemple).

- W

[MagicJohnson]

Salut.
Merci de me répondre.

Je suis navré mais je ne comprends pas ce que vous m'expliquez.

En fait, mes 20 colonnes sont déjà un condensé de mon tableau qui est composé de x fois 20 colonnes.
C'est parmi ces 20 colonnes que je veux identifier les 8 valeurs les plus élevées à la ligne 0.
Puis ceci fait, peut être en éliminant les 12 autres, je veux savoir si dans la ligne 1, on y retrouve 5 fois la valeur 1.0.
Au quel cas, je rajoute +1 à un compteur.

Donc reformuler, je ne comprends pas cette piste.
Ce que je peux avoir du mal à coder, c'est d'écrire un code qui indique à numpy de ne trier les valeurs que sur 20 colonnes par 20 colonnes en ne retenant que les 8 valeurs les + élevées.
Ce serait déjà une belle avancée .
Je peux peut être le faire sous forme de boucle mais cela ralentirait tout car numpy possède peut être une fonction qui pourrait m'aider.

Je ne sais pas si je m'explique correctement ? J'espère en tout cas.

[mango1]

Salut,

Regarde peut-être en utilisant reshape (https://numpy.org/doc/stable/referen...y.reshape.html) d'abord sur la première ligne pour avoir une matrice avec 20 colonnes ; Ensuite fais du tri sur ta matrice ligne par ligne

Refais la même chose pour la deuxième ligne

Mango1

[wiztricks]

Donc reformuler, je ne comprends pas cette piste.
Ce que je peux avoir du mal à coder, c'est d'écrire un code qui indique à numpy de ne trier les valeurs que sur 20 colonnes par 20 colonnes en ne retenant que les 8 valeurs les + élevées.

Découper par paquets de 20 ou par paquets de 3 est la même opération: découper par paquets de N et à partir de là je peux écrire:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
>>> N = 3
>>> ar = np.array([ list(range(2*N)), [1,]*2*N])
>>> ar
array([[0, 1, 2, 3, 4, 5],
       [1, 1, 1, 1, 1, 1]])
>>>

ce qui est un tableau à 2 lignes de 2 séquences à N(=3) éléments.
Le découper par paquets de 3, c'est juste ajouter une dimension (à N éléments):

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
>>> ar.reshape((-1,2,N))
array([[[0, 1, 2],
        [3, 4, 5]],
 
       [[1, 1, 1],
        [1, 1, 1]]])
>>>

Et maintenant, si on veut construire un tableau de dimension (2,2,2) où on récupère les M=2 plus grands de [0, 1, 2] et les M plus grands de [3, 4, 5] (ou autre chose), j'ai déjà la possibilité de visualiser le résultat que je cherche à obtenir.... et une séquence d'opérations qui se fout pas mal que la valeur de M soit 2, 8,... (tant qu'elle est plus petite que N).

Je ne sais pas si je m'explique correctement ? J'espère en tout cas.

Vous vous contentez de raconter ce que vous voulez faire sans prendre du recul sur les opérations à réaliser "en général" qui seront indépendantes des tailles/longueurs et qui vous empêchent aussi de visualiser quoi que ce soit sur de petits exemples.

Et sans visualiser un minimum, impossible d'imaginer quelques mots clefs pertinents pour pouvoir chercher un peu sur Internet ou la documentation numpy.

- W

[MagicJohnson]

Merci. De ce fait, je me retrouve avec un array3d. Mais comment trier de façon décroissante sur la première dimension ?

Dans votre exemple d'array, Wistricks, la seconde ligne n'est constitué que de valeur 1. Or, dans mon tableau, il y a 1 ou 0 et leur situation dans la colonne est liée à la valeur contenue dans la même colonne en ligne 0.

Je vous présente un exemple:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
a = np.array([[0.4625, 0.6856, 0.7016, 0.4912, 0.7537, 0.768, 0.5193,0.7622 ],
 [1, 1, 0, 0, 1, 1, 0, 0]])
 
[[0.4625 0.6856 0.7016 0.4912 0.7537 0.768  0.5193 0.7622]
 [1.     1.     0.     0.     0.     1.     0.     1.    ]]

Je découpe le tableau en paquets de 4:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
b = a.reshape(-1, 2, 4)
[[[0.4625 0.6856 0.7016 0.4912]
  [0.7537 0.768  0.5193 0.7622]]
 
 [[1.     1.     0.     0.    ]
  [0.     1.     0.     1.    ]]]

Me voilà avec un array en 3 dimensions.
Bien que je n'ai pas encore compris comment trier de façon décroissante, je vais tester un tri croissant.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
c = np.sort(b)
[[[0.4625 0.4912 0.6856 0.7016]
  [0.5193 0.7537 0.7622 0.768 ]]
 
 [[0.     0.     1.     1.    ]
  [0.     0.     1.     1.    ]]]

La fonction trie toutes les valeurs en rompant ainsi le lien entre mes valeurs et les 1 / 0 s'y rattachant.

[wiztricks]

Mais comment trier de façon décroissante sur la première dimension ?

En anglais, "trier" se traduit par "sort"... "numpy sort" sont donc les mots clefs à utiliser pour chercher avec un moteur de recherche ce qu'on peut faire avec numpy...
Comme on part d'un exemple à dimensions (2, 2, 3), c'est plus facile pour tester et montrer le code que vous avez essayé.

- W

[mango1]

Tu peux faire un reshape (N, 20) d'abord sur la première ligne ; puis tu relèves les indices par ordre croissant des 8 plus grands de chaque ligne ; ça nécessite de créer une fonction avec en entrée ta matrice reshape et en sortie une matrice d'indices (N, 8)

Ensuite sur ton reshape de ta deuxième ligne, à partir de ta matrice d'indices tu fais les comptes de ton nombre de 1 ; il faut aussi créer une fonction avec en entrée la matrice d'indices et ton reshape de la 2° ligne et en sortie le décompte par ligne (N,1)

Mango1

[MagicJohnson]

En anglais, "trier" se traduit par "sort"... "numpy sort" sont donc les mots clefs à utiliser pour chercher avec un moteur de recherche ce qu'on peut faire avec numpy...
- W

Merci. Sous votre impulsion, j'ai fini par trouver comment effectuer le tri décroissant en faisant une recherche comme vous l'avez indiqué:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

array_tri = np.sort(array_test, axis=1)[:, ::-1]

Comme on part d'un exemple à dimensions (2, 2, 3), c'est plus facile pour tester et montrer le code que vous avez essayé.
- W

C'est vrai que c'était plus simple d'observer ce que cela donne sur de petites quantités.

[MagicJohnson]

Tu peux faire un reshape (N, 20) d'abord sur la première ligne ; puis tu relèves les indices par ordre croissant des 8 plus grands de chaque ligne ; ça nécessite de créer une fonction avec en entrée ta matrice reshape et en sortie une matrice d'indices (N, 8)

Ensuite sur ton reshape de ta deuxième ligne, à partir de ta matrice d'indices tu fais les comptes de ton nombre de 1 ; il faut aussi créer une fonction avec en entrée la matrice d'indices et ton reshape de la 2° ligne et en sortie le décompte par ligne (N,1)

Mango1

Oui merci. C'est ce que je vais faire.
Il n'est pas nécessaire dans un premier temps de créer un tableau à 3 dimensions mais plutôt c'est vrai de reformer ma première ligne en tableau à 2d.

Du coup, ce sont les 8 premiers indices des valeurs les plus élevées du tableau trié que je vais récupérer. J'ai trouvé ceci, cela me parait juste:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

array_indices = np.argsort(array_reforme, axis=1)[:, ::-1][:,0:8]

Merci beaucoup pour le coup de main, je n'y serais jamais parvenu seul.

Ma difficulté maintenant va être de compter mes 1 sur ma matrice rescapé de la ligne 2 sur la foi de ma matrice d'indices.

De quel côté me faut-il chercher ? Il doit tout de même y'avoir autre chose à faire qu'une boucle qui m'obligerait à extraite ligne par ligne les indices trouvés dans ma matrice indices ?

Merci bcp en tout cas. Sympa à tous.

[mango1]

La suite ne devrait pas être trop dure ; il faut passer en revue le reshape de la 2° ligne, ligne par ligne et élément par élément:
si l'indice de l'élément correspond à un indice dans la matrice indice et si l'élément vaut 1 alors on implémente un chrono sinon on fait rien

Mango1

[MagicJohnson]

La suite ne devrait pas être trop dure ; il faut passer en revue le reshape de la 2° ligne, ligne par ligne et élément par élément:
si l'indice de l'élément correspond à un indice dans la matrice indice et si l'élément vaut 1 alors on implémente un chrono sinon on fait rien

Mango1

C'est ce que je redoutais, de devoir faire usage d'une boucle pour cette tâche. Ca va considérablement tout ralentir. IL n'y a pas un autre moyen ?

[mango1]

Tout dépend de ton application pour le temps de calcul; ici la démarche peut être optimisée mais je ne vois pas comment ne pas faire de boucle au moins sur les N lignes. Même en résolution matricielle avec du Gauss tu passes par une boucle. Si le temps de calcul est vraiment un requis alors oriente toi vers du C++ -> C -> fortran ; mais avant je te conseille de tester ton code et de mesurer le temps de calcul