Discussion :

[selmagsi]

salut les dévelppeurs,
J'ai besoin de travailler avec une liste (de listes) de Taille X. elle peut aller jusqu'à 149. comment faire pour la déclarer sans préciser la taille?
La déclaration ci dessous me cause problème :

Code :

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

1
2
 
 Pt=[[]]

exception:

Code :

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

1
2
3
4
 
    Pt[ti].append(X[j])
 
IndexError: list index out of range

par contre cette déclaration marche parfaitement :

Code :

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

1
2
 
Pt=149*[[]]

comment faire pour que la taille soit dynamique?

[wiztricks]

Salut,

J'ai besoin de travailler avec une liste (de listes) de Taille X. elle peut aller jusqu'à 149. comment faire pour la déclarer sans préciser la taille?

Vous ne déclarez pas une liste mais vous assignez un objet list à une variable.
Exemple: L = [] assigne à L une liste vide.
Et si vous voulez créer une liste de X éléments, vous fabriquez cette liste sous forme littérale: L = [ 0, 0, 0, 0 ] ou L = [0,] * 4 ou via une boucle L = [ 0 for _ in range(4) ].

- W

[Sve@r]

comment faire pour que la taille soit dynamique?

Bonjour

Une liste est toujours dynamique. Dès qu'on y insère/ajoute un élément elle s'agrandit pour y faire rentrer l'élément inséré/ajouté

par contre cette déclaration marche parfaitement : Pt=149*[[]]comment faire pour la déclarer sans préciser la taille?

Soit on déclare une liste vide, et ensuite on crée les éléments à la volée via append() ou insert(), soit on déclare une liste contenant n éléments (ex Pt=[123,] * 5 => va créer [123, 123, 123, 123, 123] mais dans ce cas, on est obligé de préciser la taille.
Ici, avec Pt=[[]] * 149 on crée une liste de 149 listes vides. Et si on avait écrit avec Pt=[[None] * 149] * 149 ça aurait créé 149 listes contenant chacune 149 éléments (tous à None ce qui permet de symboliser l'élément vide).

[selmagsi]

Ok la c'est compris.
Maintenant j'ai un autre problème avec les élément de Pt , comme j'ai mentionné se sont eux meme des listes. mon implémentation sencait donner des liste différentes mais la toute les liste sont identique , je ne sais pas pourquoi!!

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
 
 while(1):
 
  ts=0
  while(1): 
 
           if(X[t[ts]] in Q): 
 
               break
           t.remove(t[ts]) 
 
 
  cpt=0
 
  for j in range(1, len(X)):
 
          x=distance.euclidean(X[t[ts]], X[j]) 
          if (x>=s and (X[j] in Q)):
 
            Pt[ti].append(X[j])
 
            Q.remove(X[j])
 
            cpt=cpt+1;
 
  if(cpt!= 0):
         ti=ti+1
 
         k.append(X[t[ts]])
  t.remove(t[ts])
  if(len (Q)==0 or len (t)==0):
 
         break 
  #del Pt[ti][:]   
 
 return S

[wiztricks]

mon implémentation sencait donner des liste différentes mais la toute les liste sont identique

Ben si vous écrivez:

Code :

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

1
2
3
4
5
>>> A = [1, 2, 3]
>>> L = [ A,]*3
>>> L
[[1, 2, 3], [1, 2, 3], [1, 2, 3]]
>>>

vous vous retrouvez avec un truc qui ressemble à une liste de listes alors qu'en fait vous avez fabriqué une liste contenant 3 fois le même objet A. Donc s'il change:

Code :

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

1
2
3
4
>>> A[0] = 'XXX'
>>> L
[['XXX', 2, 3], ['XXX', 2, 3], ['XXX', 2, 3]]
>>>

les 3 références changent.

je ne sais pas pourquoi!!

Parce que c'est comme çà que Python fonctionne et votre code me semble bien compliqué pour que vous en soyez surpris sauf à avoir survolé votre tuto. préféré.

- W

[flapili]

Bonjour,
J'aimerai bien aider mais votre code est tout bonnement impossible à comprendre, il semble mal pensé dès le départ...

D'habitude en 1 coup d'œil on est capable de comprendre ce que cherche à faire un code mais alors là c'est mission impossible.

Énoncé ce que vous voulez faire s'il vous plaît se sera le mieux à faire. À la lecture du code on remarque pas mal de mimiques du C (peut être je me trompe), commencé par de l'algorithmie, une feuille et un crayon.

Ps le second while(1) est indenté? Sur mobile on dirais bien mais sur mobile pas évident à voir et si il l'est alors l'indentation n'est pas cohérente et est différente toutes les 3 lignes...

[selmagsi]

Ben si vous écrivez:

vous vous retrouvez avec un truc qui ressemble à une liste de listes alors qu'en fait vous avez fabriqué une liste contenant 3 fois le même objet A. Donc s'il change:


- W

ça je n'ai pas compris.quelle ligne prouve ça!!

[selmagsi]

Bonjour,
J'aimerai bien aider mais votre code est tout bonnement impossible à comprendre, il semble mal pensé dès le départ...

D'habitude en 1 coup d'œil on est capable de comprendre ce que cherche à faire un code mais alors là c'est mission impossible.

Énoncé ce que vous voulez faire s'il vous plaît se sera le mieux à faire. À la lecture du code on remarque pas mal de mimiques du C (peut être je me trompe), commencé par de l'algorithmie, une feuille et un crayon.

Ps le second while(1) est indenté? Sur mobile on dirais bien mais sur mobile pas évident à voir et si il l'est alors l'indentation n'est pas cohérente et est différente toutes les 3 lignes...

Meric pour vos remarque constructives.
Bh c'est justement un algorithme que je suis en train de coder en python qui donne ça! bh je ne sais pas pourquoi tous les élément de Pt sont identiques , quand je suis a la position ti de Pt et que je rajoute un X je fait un remove avant d'incrémenter le ti , mais dans mon cas X et dans Pt[ti] et dans Pt[ti+1].

[flapili]

Meric pour vos remarque constructives.
Bh c'est justement un algorithme que je suis en train de coder en python qui donne ça! bh je ne sais pas pourquoi tous les élément de Pt sont identiques , quand je suis a la position ti de Pt et que je rajoute un X je fait un remove avant d'incrémenter le ti , mais dans mon cas X et dans Pt[ti] et dans Pt[ti+1].

on ne code pas un algorithme, on code un .. code.
vous seule comprenez ce que vous dites car vous seul avez l'énoncé du problème sous les yeux, qu'est ce que S? qu'est ce que ti ? Pt? X ?

ne serais t'il pas plus simple de donner l'énoncer du problème ?

[selmagsi]

on ne code pas un algorithme, on code un .. code.
vous seule comprenez ce que vous dites car vous seul avez l'énoncé du problème sous les yeux, qu'est ce que S? qu'est ce que ti ? Pt? X ?

ne serais t'il pas plus simple de donner l'énoncer du problème ?

Ok , je laisse ci-joint mon algo et aussi le code complet!

l'algorithme:



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
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
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
 
# -*- coding: utf-8 -*-
"""
Created on Fri Nov 02 22:02:08 2018
 
@author: user
"""
from scipy.spatial import distance
import numpy as np
 
def ReadData(fileName): 
 
 f = open(fileName, 'r'); 
 
 lines = f.read().splitlines(); 
 f.close(); 
 
 items = []; 
 
 for i in range(1, len(lines)): 
        line = lines[i].split(','); 
        itemFeatures = []; 
 
        for j in range(len(line)-1): 
            v = float(line[j]); # Convert feature value to float 
            itemFeatures.append(v); # Add feature value to dict 
 
        items.append(itemFeatures); 
 
 return items; 
 
def normalize(lst):
    s = sum(lst)
    return map(lambda x: float(x)/s, lst)
 
def BiGC(X,s):
 S=149*[0]
 
 for i in range(1, len(X)): 
      #euclidian distance
 
    for j in range(1, len(X)):
          if j!=i:
            S[i]=S[i]+distance.euclidean(X[i], X[j])
    S[i]= (S[i])/2
 print S
 Q=X[:]
 Q=list(X)
 ti=0;
 x=0;
 Pt=149*[[]]
 k=[]
 dist=149*[0]
 cpt=0
 #repeat
 t=np.argsort(S)
 t =t[::-1]
 t=t.tolist()
 print S[12]
 print S[117] 
 while(1):
 
  ts=0
  while(1): 
 
           if(X[t[ts]] in Q): 
 
               break
 
           t.remove(t[ts])
 
 
  cpt=0
  for j in range(1, len(X)):
 
          x=distance.euclidean(X[t[ts]], X[j])
          dist[j]=x
  norm= normalize(dist)
 
  for j in range(1, len(X)):     
          if (norm[j]>=s and (X[j] in Q)):
 
            Pt[ti].append(X[j]) 
            Q.remove(X[j])
            cpt=cpt+1;
 
  if(cpt!= 0):
         ti=ti+1
 
         k.append(X[t[ts]])
  t.remove(t[ts])
  print ('Pt num ', ti, ' = ', len (Pt[ti]))
  if(len (Q)==0 or len (t)==0):
 
         break 
  #del Pt[ti][:]   
 
 return S
 
X=100*[];
items=ReadData("C:\Users\user\Desktop\Python projects workspace\KmeansClustering\iris.txt")
S=BiGC(items,0.006)

au fait mon code commence à partir de la ligne 36 , le début c'est juste pour lire mon dataset

[flapili]

Désolé mais je n'est pas les notions nécessaires pour comprendre de A à Z x)
l'indentation avec 1 espace n'aide pas :/

pour commencer pourquoi ne pas faire une fonction somme ?
La fonction BIGC prend en paramètre X et s, où est utilisé s ?
vous devez commencer à i=1 cependant en python (et dans la quasi totalité des langages) une liste commence à l'index 0 et ça peut poser des difficultés, il va falloir faire un choix mais dans votre cas est-ce que X₀ est incohérent mathématiquement ? si non alors ce n'est qu'un choix de nomenclature.

y'as pas mal de chipotage à faire un peu partout avec des ; mais chaque chose en son temps.

désolé à défaut de pouvoir apporter du code pour le moment je donne quelques maigres pistes, je vais continuer de chercher dans un premier temps s'il y a des incohérences logiques.

[selmagsi]

Merci pour votre attention. Au fait moi aussi je ne suis plus sur pc ca m a rendu KO cet Algo.
Au fait je debute en Python et je vous bien qu il tolére bien l'abcense des ; (contrairement aux exigences stricte s de Java).
Pour s je l'utilise au niveau de la ligne 89. Puis pourquoi fonction somme?? Vous avez raison pour les indices de la listes

[flapili]

Merci pour votre attention. Au fait moi aussi je ne suis plus sur pc ca m a rendu KO cet Algo.
Au fait je debute en Python et je vous bien qu il tolére bien l'abcense des ; (contrairement aux exigences stricte s de Java).
Pour s je l'utilise au niveau de la ligne 89. Puis pourquoi fonction somme?? Vous avez raison pour les indices de la listes

pour s je viens de voir effectivement à la ligne 81, c'est à si perdre entre S s tspar contre qu'est ce que X parce que se n'est pas très clair, pourquoi copier X vers Q pour ne plus utiliser X ?
quand je parle d'une fonction somme c'est quelque chose dans se genre

Code :

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

1
2
3
4
5
6
7
8
def somme(x):
	sommes = [0]*len(x)
	for i in range(0, len(x)-1):
		for j in range(0, len(x)-1):
			if j!=i:
				sommes[i] += distance.euclidean(s[i], s[j])
		sommes[i] /= 2
	return sommes

attention fait à la vas vite sur téléphone il est possible qu'une erreur se soit glissée quelque part

[selmagsi]

X c'est l'ensemble de mes points. Sachant q X_i est un vecteur. Je calcule le S (shapley value de chaque x_i) . S_1 correspond a X_1, ..S_2 correspond a X_2... etc.
Je copoe X dans Q pour regrouper les element de Q (X) et je garde X pour pour avoir reference au shapley value de chaque X_i

[flapili]

X c'est l'ensemble de mes points. Sachant q X_i est un vecteur. Je calcule le S (shapley value de chaque x_i) . S_1 correspond a X_1, ..S_2 correspond a X_2... etc.
Je copoe X dans Q pour regrouper les element de Q (X) et je garde X pour pour avoir reference au shapley value de chaque X_i

c'est un ensemble de point ok mais sous quelle forme ils sont stockés ? liste de listes je suppose mais un exemple simple serais parlant.
Remplacez def somme(x): par def shapley(x): dans mon exemple et le tour est joué !

[selmagsi]

Merci c'est tres gentil. J essayerai demain matin tous ces changemenrs. Pour X: [[1.2,2.3,4.6, 3.3],[1.3,2.3,4.7,3.4].... ETC]

[Pyramidev]

Bonjour,

Attention, dans ton code, Pt=149*[[]] tombe dans le piège signalé par wiztricks : il ne s'agit pas d'une liste de 149 listes vides différentes, mais d'une liste de 149 fois la même liste vide !

Illustration :


Pour avoir 149 listes vides différentes, il faut écrire Pt=[[] for _ in range(149)].

Illustration :

Ici, avec Pt=[[]] * 149 on crée une liste de 149 listes vides. Et si on avait écrit avec Pt=[[None] * 149] * 149 ça aurait créé 149 listes contenant chacune 149 éléments (tous à None ce qui permet de symboliser l'élément vide).

Même remarque. Dans chacun de ces deux exemples, il s'agit de 149 fois la même liste.

[lg_53]

1) Vous pourriez garder les même notation que dans l'algorithme pour que l'on s'y retrouve. phi c'est phi, pourquoi le rebaptiser S ?

2) Ensuite la fonction f qui est dans l'algo c'est quoi ? Vous vous avez l'air de considérer qu'elle n'est pas là, je me trompe ?

3) Ensuite dans l'algo K ne sert pas. Donc ca m'étonnerait que la sortie soit S, je pense que c'est K, et là ca aurait un sens de le calculer.

4) Votre double boucle while, je ne comprends absolument pas. Dans l'algo il y a clairement un while, et il devrait s'écrire comme cela, et je ne le vois pas :

Code :

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

while len(Q) != 0 :

5) Pt est une variable intermédiaire propre à chaque boucle. Pourquoi l'initialiser à l'extérieur de la boucle ? Vous n'avez qu'à le construire à l'intérieur ! (On peut vouloir initialiser cette variable à l'extérieur de la boucle pour des raisons de performances, mais pour l'instant on en n'est pas du tout à ce point là, il vous faut déjà qqch qui fonctionne avant)

6)

Code :

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

1
2
Q=X[:]
 Q=list(X)

Donc tout simplement Q=list(X) la seconde ligne venant écrasé la valeur de Q calculée à la première ligne ...

7) On pourrait se servir un peu plus de numpy. Je pense notamment à np.where pour détecter quels sont les indices i tels que x_i est dans Q. Egalement il existe aussi une fonction np.argmax.

8) Le code permettant lecture de vos données, on s'en fiche presque, et il ne nous apporte absolument rien pour tester votre code puisque nous n'avons aucune idée de ce qu'il y a dans X. Au lieu de mettre cela, lorsque vous avez exécuter votre code, faites un print(X) et ensuite contentez vous de nous présenter un programme qui commence par X= ....

9) Et il y aurait encore beaucoup à dire, mais déjà si on résolvait tous cela je crois qu'on y verrais beaucoup plus clair.

[selmagsi]

Merci , c'est très intéressant, oui oui effectivement la sortie c'est K , je me suis juste trompée... Je vais vite prendre en considération vos remarque et je re poste mon code, merci infiniment

Voici mon code mieux amélioré.

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
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
 
def normalize(lst):
    s = sum(lst)
    return map(lambda x: float(x)/s, lst)
 
def shapleyV(x):
	sv = [0]*len(x)
	for i in range(0, len(x)-1):
		for j in range(0, len(x)-1):
			if j!=i:
				sv[i] += distance.euclidean(x[i], x[j])
		sv[i] /= 2
	return sv    
 
def BiGC(X,s):
 
 phi=shapleyV(X)
 Q=list(X)
 ti=0;
 x=0;
 Pt=[[] for _ in range(149)]
 k=[]
 dist=149*[0]
 cpt=0
 #repeat
 t=np.argsort(phi)
 t =t[::-1]
 t=t.tolist()
 
 while(1):
 
  ts=0
  while(1): 
 
           if(X[t[ts]] in Q): 
 
               break
 
           t.remove(t[ts])
 
 
  cpt=0
  for j in range(0, len(X)-1):
 
          x=distance.euclidean(X[t[ts]], X[j])
          dist[j]=x
  norm= normalize(dist)
 
  for j in range(1, len(X)):     
          if (norm[j]>=s and (X[j] in Q)):
 
            Pt[ti].append(X[j]) 
            Q.remove(X[j])
            cpt=cpt+1;
 
  if(cpt!= 0):
         ti=ti+1
 
         k.append(X[t[ts]])
  t.remove(t[ts])
  print ('Pt num ', ti, ' = ', len (Pt[ti]))
  if(len (Q)==0 or len (t)==0):
 
         break 
  #del Pt[ti][:]   
 print k
 print Pt
 return k
 
X=100*[];
items=ReadData("C:\Users\user\Desktop\Python projects workspace\KmeansClustering\iris.txt")
S=BiGC(items,0.006)

Je suis tout a fait d'accord avec vous, len(Q)=0 la seule condition qui met fin a la boucle, mais le choix de s est difficile pour tomber pile sur ça , du coup pour voir claire je me suis aidée de len t aussi en attendant trouver le bon s(c'est un seuil). une fois sur que le code est bien écrit je me documenterai pour np.where (je suis juste débutante en Python et je vous remercie pour ce coup de pousse ) . pour Pt il me sera utile , c'est du clustering que je fais, k contient les centroid et Pt les point de chaque cluster.
toute remarque est la bienvenue, encore merci

[lg_53]

OK. Donnez nous un X d'input qu'on puisse essayer des trucs !

Et si l'algo ne termine jamais (c-à-d que Q n'atteint pas l'ensemble vide) c'est qu'il est mal écrit dans votre papier. Ou alors qu'un bug de codage de votre part fait que ca ne se termine plus. La 2eme possibilité étant plus probable, pour contrer cela, vous pouvez mettre un nombre d'itération max. Et vous quitter la boucle while soit si len(Q)==0, soit si le nombre d'itération a été dépassée. Et là vous êtes sur de sortir à un moment donné, et vous pourrez voir ce qui se passe.