Discussion :

[Hofman]

Bonjour à tous,

Voici mon problème :

J'ai deux listes :

Index list: [0, 5, 5, 6, 0, 1, 1, 8, 9, 9]
Index list Mfccs : [0.640495, 0.4822588, 0.6523488, 0.74474275, 0.5423001, 0.85711163, 0.724612, 0.5099624, 0.9696293, 0.97258127]

La deuxième liste contient les valeurs réels et la première, les arguments des valeurs de la deuxième.

Mon but est de choisir dans le première liste, l'argument qui ressort le plus souvent.
C'est facile lorsqu'il n'y à pas deux doublons comme dans une liste comme celle-ci : Index list: [1, 6, 6, 6, 6, 9, 6, 2, 6, 2]
Ici je ressort donc l'argument 6. avec une simple ligne de code : predicted_index = np.bincount(Index list).argmax()

Mais dans le cas du début, j'ai 4 doublons ! Deux 0, deux 5, deux 1 et deux 9.
Je veux donc récupérer les valeurs réels de tous ces chiffres (dans la liste Index list Mfccs), les comparer et ne ressortir que la valeur maximale.
Je voudrais faire de même si une liste qui ressort deux valeurs trois fois comme celle-ci : Index list: [1, 4, 3, 4, 4, 9, 6, 5, 5, 5]
Etc.

Merci d'avance pour votre aide

[Sve@r]

Bonjour

Suis pas certain d'avoir bien compris. Tu veux récupérer les index qui ressortent le plus, et s'il y a plusieurs ex-aequo, récupérer la valeur la plus forte de ces index

Si c'est ça, une solution est de passer par un histogramme pour récupérer les index et leurs répétitions. Ensuite suffit de récupérer les index ayant le max de rep puis regarder les valeurs associées à ces index et prendre la max.

Code python :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#!/usr/bin/env python3
# coding: utf-8
 
idx=[0, 5, 5, 6, 0, 1, 1, 8, 9, 9]
val=[0.640495, 0.4822588, 0.6523488, 0.74474275, 0.5423001, 0.85711163, 0.724612, 0.5099624, 0.9696293, 0.97258127]
 
# Histogramme des index et de leur répétition
histo=dict((n, idx.count(n)) for n in set(idx))
print(histo)
 
# Extraction des index répétés le max
extract=tuple(k for (k, v) in histo.items() if v == max(histo.values()))
print(extract)
 
# Affichage de la valeur la plus forte prise parmis les index extraits
print(max(val[n] for n in extract))

Bon bien entendu on peut aussi écrire tout ça sur une super énorme grosse ligne remplie d'itérables créés en intension mais je pense que séparer les étapes c'est plus lisible...

[Hofman]

Bonjour Sve@r,

Tout d'abord, merci pour cette réponse rapide !

C'est tout à fait ça, ma question a bien été comprise.

La proposition de code est tout à fait compréhensible et simple à lire grâce à la séparation des trois étapes.

Cependant, tout fonctionne bien sauf pour la troisième partie.
En effet, la valeur la plus forte prise parmi les indexs extrait est souvent fausse.
Je n'arrive pas à comprendre pourquoi il ressort souvent une valeur qui ne fait pas partie des indexs.

Aussi lorsqu'il y a plusieurs doublons comme dans cet exemple :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
idx=[5, 2, 5, 8, 0, 1, 2, 4, 7, 3]
val=[0.640495, 0.4822588, 0.6523488, 0.74474275, 0.5423001, 0.85711163, 0.724612, 0.5099624, 0.9696293, 0.97258127]
 
# Histogramme des index et de leur répétition
histog=mat.hist(idx)
histo=dict((n, idx.count(n)) for n in set(idx))
print(histo)
 
# Extraction des index répétés le max
extract=tuple(k for (k, v) in histo.items() if v == max(histo.values()))
print(extract)
 
# Affichage de la valeur la plus forte prise parmis les index extraits
print(max(val[n] for n in extract))
 
runfile('C:/Users/c.hofman.BORDEAUX/Desktop/Codes python/04 Son/Genre Classification/Liste.py', wdir='C:/Users/c.hofman.BORDEAUX/Desktop/Codes python/04 Son/Genre Classification')
{0: 1, 1: 1, 2: 2, 3: 1, 4: 1, 5: 2, 7: 1, 8: 1}
(2, 5)
0.85711163

Le code ressort 0.85 alors qu'il devrait nous donner 0.72

Ou un triplé comme dans cet exemple :

Code :

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

1
2
3
4
5
6
7
8
9
 
idx=[5, 5, 5, 6, 0, 1, 2, 4, 2, 3]
val=[0.640495, 0.4822588, 0.6523488, 0.74474275, 0.5423001, 0.85711163, 0.724612, 0.5099624, 0.9696293, 0.97258127]
 
Résultat : 
runfile('C:/Users/c.hofman.BORDEAUX/Desktop/Codes python/04 Son/Genre Classification/Liste.py', wdir='C:/Users/c.hofman.BORDEAUX/Desktop/Codes python/04 Son/Genre Classification')
{0: 1, 1: 1, 2: 2, 3: 1, 4: 1, 5: 3, 6: 1}
(5,)
0.85711163

Le code ressort 0.85 alors qu'on devrait avoir 0.65.

Merci d'avance
Hofman

[Hofman]

En parallèle à votre réponse, j'ai travaillé sur mon code qui est plus brouillon et mon compréhensible.
J'ai utilisé une boucle for et listé tous les cas possibles, doublons, triplés, quadruplés , etc.

Le seul soucis c'est que lorsque dans la liste d'index, il y a un triplé et un doublons, et que le dernier chiffre de la liste fait partie du doublon, il sera pris en compte et le code rendra un résultat faussé si sa valeur est plus grande que celle du triplé.
Voici l'exemple pour une meilleure compréhension !

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
 
index_list = [5, 5, 1, 6, 5, 5, 5, 8, 9, 1]
index_list_mcfccs = [0.640495, 0.4822588, 0.6523488, 0.74474275, 0.5423001, 0.85711163, 0.724612, 0.5099624, 0.9696293, 0.97258127]
 
result_mcfccs = []
result2 = 0
result3 = 0
result4 = 0
result5 = 0
 
 
for idx, index in enumerate(index_list):
    if index_list.count(index) == 2:
        result_mcfccs.append(index_list_mcfccs[idx])
        result2 = max(result_mcfccs)
        print("2 ", result2)
    elif index_list.count(index) == 3:
        result_mcfccs.append(index_list_mcfccs[idx])
 
        if result2 in result_mcfccs:
            result_mcfccs.remove(result2)
 
        result3 = max(result_mcfccs)
        print("3 ", result3)
 
    elif index_list.count(index) == 4:
        result_mcfccs.append(index_list_mcfccs[idx])
 
        if (result2, result3) in result_mcfccs:
            result_mcfccs.remove(result2, result3)
 
        result4 = max(result_mcfccs)
        print("4 ", result4)
 
    elif index_list.count(index) == 5:
        result_mcfccs.append(index_list_mcfccs[idx])
 
        if (result2, result3, result4) in result_mcfccs:
            result_mcfccs.remove(result2, result3, result4)
 
        result5 = max(result_mcfccs)
        print("5 ", result5)
 
print("Résultat final : ", result_mcfccs)
print("Résultat final : ", max(result_mcfccs))

Ici le résultat sera la valeur du dernier 1 car c'est la valeur la plus grande, 0.97 alors qu'il y a cinq 5 et que la valeur qui aurait du ressortir est 0.85.

Voici ce que rends le code :

Code :

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

1
2
3
4
5
6
7
8
9
5  0.640495
5  0.640495
2  0.6523488
5  0.6523488
5  0.85711163
5  0.85711163
2  0.97258127
Résultat final :  [0.640495, 0.4822588, 0.6523488, 0.5423001, 0.85711163, 0.724612, 0.97258127]
Résultat final :  0.97258127

[Hofman]

Re-bonjour,

J'ai finalement, trouvé une solution qui utilise un compromis entre les deux méthodes !

J'utilise l'histogramme. Mais je ne sélectionne que les valeurs des index se répétant le plus.

Voici le code :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
index_list = [1, 1, 1, 3, 5, 4, 7, 9, 9, 0]
mfccs_list = [0.640495, 0.4822588, 0.6523488, 0.74474275, 0.5423001, 0.85711163, 0.724612, 0.5099624, 0.9696293, 0.97258127]
 
# Histogramme des index et de leur répétition
histogram = dict((n, index_list.count(n)) for n in set(index_list))
 
print("Histogramme : ","\n", histogram)
#print ("\nItems de l'histogramme : ","\n", histogram.items())
print ("\nNbre d'apparation des index : ","\n", histogram.values())
print ("\nMaximum d'apparitions d'un même index : ", max(histogram.values()))
 
result_mcfccs = []
 
for m, n in enumerate(index_list):
    if index_list.count(n) == max (histogram.values()):
        result_mcfccs.append(mfccs_list[m])
print("\nListe des Mfccs des index apparaissants le plus :","\n", result_mcfccs)
result2 = max(result_mcfccs)
print("\nRésultat final :", result2)

Résultat :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
runfile('C:/Users/c.hofman.BORDEAUX/Desktop/Codes python/04 Son/Genre Classification/Liste.py', wdir='C:/Users/c.hofman.BORDEAUX/Desktop/Codes python/04 Son/Genre Classification')
Histogramme :  
 {0: 1, 1: 3, 3: 1, 4: 1, 5: 1, 7: 1, 9: 2}
 
Nbre d'apparation des index :  
 dict_values([1, 3, 1, 1, 1, 1, 2])
 
Maximum d'apparitions d'un même index :  3
 
Liste des Mfccs des index apparaissants le plus : 
 [0.640495, 0.4822588, 0.6523488]
 
Résultat final : 0.6523488

Ainsi même si un doublons est présent avec un triplé, les valeurs du doublons ne seront pas prises en compte.

Merci pour l'aide apportée !
Cordialement
Hofman

[Sve@r]

En effet, la valeur la plus forte prise parmi les indexs extrait est souvent fausse.
Je n'arrive pas à comprendre pourquoi il ressort souvent une valeur qui ne fait pas partie des indexs.

Aussi lorsqu'il y a plusieurs doublons comme dans cet exemple :

Code :

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

1
2
idx=[5, 2, 5, 8, 0, 1, 2, 4, 7, 3]
val=[0.640495, 0.4822588, 0.6523488, 0.74474275, 0.5423001, 0.85711163, 0.724612, 0.5099624, 0.9696293, 0.97258127]

Le code ressort 0.85 alors qu'il devrait nous donner 0.72

Ben non, tel que j'ai compris le truc, 0.85 est la bonne valeur
Ici l'index 2 et l'index 5 se retrouvent tous deux 2 fois et les autres une fois. Les index 2 et 5 sont donc les bons candidats. J'ai mis en rouge leurs valeurs associées.
Et entre idx[2] (0.6523488) et idx[5] (0.85711163), la max est bien 0.85711163

Ou un triplé comme dans cet exemple :

Code :

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

1
2
3
idx=[5, 5, 5, 6, 0, 1, 2, 4, 2, 3]
val=[0.640495, 0.4822588, 0.6523488, 0.74474275, 0.5423001, 0.85711163, 0.724612, 0.5099624, 0.9696293, 0.97258127]

Le code ressort 0.85 alors qu'on devrait avoir 0.65.

Pareil, le 5 étant le seul candidat à se retrouver 3 fois, c'est idx[5] qui ressort (0.85711163)

J'ai finalement, trouvé une solution qui utilise un compromis entre les deux méthodes !

J'utilise l'histogramme. Mais je ne sélectionne que les valeurs des index se répétant le plus.

Ben oui, c'est aussi ce que je fais avec extract=tuple(k for (k, v) in histo.items() if v == max(histo.values())). Je ne garde que les index dont la répétition est égale à la répétition max trouvée dans l'histogramme.

Code :

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

1
2
3
index_list = [1, 1, 1, 3, 5, 4, 7, 9, 9, 0]
mfccs_list = [0.640495, 0.4822588, 0.6523488, 0.74474275, 0.5423001, 0.85711163, 0.724612, 0.5099624, 0.9696293, 0.97258127]
Résultat final : 0.6523488

Ben le résultat ne correspond pas à ce que j'ai prévu. L'index "1" étant le plus présent (3 fois) et aussi le seul candidat, mfccs_list[1] vaut 0.4822588 et non 0.6523488. C'est aussi ce que ressort mon code.

C'est tout à fait ça, ma question a bien été comprise.

Ben...