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