Discussion :

[Anna69]

Bonjour,
Je veux créer un programme qui permet de modéliser la propagation d'une épidémie. J'ai crée 4 classe d'agents(S,E,I,R), le programme se déroule comme suit:
au départ on suppose que tous les agents sont dans la classe S et on infecte quelques uns (E), les agents sont supposé connectés (c-a d chaque agent a ces voisins) le passage de la classe S vers E se fait par la valeur b, puis l'agent reste dans la classe E pour une période (latencytime) puis ils passe à la classe I ou il reste une période (recoverytime) ensuite il passe a la classe R
Le problème est que ma liste des agents I ne se remplit pas!!
Voici mon 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
103
104
 
        self.b = b
        self.e = e
        self.g = g
        self.t = 0
        self.p = p
 
        self.N = S + E
 
 
        self.sAgentList = []
        self.eAgentList = []
        self.iAgentList = []
        self.rAgentList = []
 
 
        self.sList = []
        self.eList = []
        self.iList = []
        self.rList = []
        self.newIList = []
 
 
        self.latencyTimesHeap = []
        self.recoveryTimesHeap = []
 
        allAgents = range(self.N)
        random.shuffle(allAgents)
 
        self.sAgentList = copy.copy(allAgents)
 
        #infecter quelques uns a t = 0
        self.indexCases = []
        for i in xrange(E):
            indexCase = self.sAgentList[0]
            self.indexCases.append(indexCase)
            self.latentAgent(indexCase)
            self.eAgentList.append(indexCase)
 
 
    def latentAgent(self,agent):
         self.sAgentList.remove(agent)
         latencyTime = self.t + scipy.random.exponential(1/self.e)
         heapq.heappush(self.latencyTimesHeap, (latencyTime, agent))
 
 
    def infectAgent(self,agent):
        self.eAgentList.remove(agent)         
 
        recoveryTime = self.t + scipy.random.exponential(1/self.g)       
 
        heapq.heappush(self.recoveryTimesHeap, (recoveryTime, agent))
 
        return 1
 
    def recoverAgents(self):        
        recoverList = []
        if len(self.recoveryTimesHeap) > 0:
            while self.recoveryTimesHeap[0][0] <= self.t:
                recoveryTuple = heapq.heappop(self.recoveryTimesHeap)
                recoverList.append(recoveryTuple[1])
                if len(self.recoveryTimesHeap) == 0:
                    break
 
        return recoverList
 
    def run(self):        
        while len(self.eAgentList) > 0:
            tempEAgentList = []
            infectList = []
            recoverList = []
            newE = 0    
            for eAgent in self.eAgentList:
                for agent in self.adjacencyList[eAgent]:
                    if agent in self.sAgentList:
                        if (random.random() < self.e): 
                            newE += self.latentAgent(agent)
                            tempEAgentList.append(agent)
 
            recoverList = self.recoverAgents()
 
            for infectAgent in infectList:
                self.eAgentList.remove(infectAgent)
                self.iAgentList.append(infectAgent)
 
            for recoverAgent in recoverList:
                self.iAgentList.remove(recoverAgent)
                self.rAgentList.append(recoverAgent)
 
 
            #ajouter un nouveau infecté
            self.eAgentList.extend(tempEAgentList)
 
            self.sList.append(len(self.sAgentList))
            self.eList.append(len(self.eAgentList))
            self.iList.append(len(self.iAgentList))
            self.rList.append(len(self.sAgentList))
            self.newEList.append(newE)            
            self.t += 1
            print('t', self.t, 'numS', len(self.sAgentList),'numE', len(self.eAgentList), 'numI', len(self.iAgentList) )
 
            random.shuffle(self.eAgentList)
 
        return [self.sList, self.eList, self.iList, self.rList, self.newIList]

Merci par l'avance

[VinsS]

Salut,

Il s'agit de la liste self.iAgentList ?

Comme ton code n'est pas testable, tout ce que l'on peut te conseiller c'est de rajouter des print ici:

Code :

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

1
2
3
4
5
6
7
8
 
            for infectAgent in infectList:
                self.eAgentList.remove(infectAgent)
                self.iAgentList.append(infectAgent)
 
            for recoverAgent in recoverList:
                self.iAgentList.remove(recoverAgent)
                self.rAgentList.append(recoverAgent)

pour voir ce qui s'y passe.

[Anna69]

Bonjour,
Merci pour votre réponse,
Effectivement, le problème est dans la liste: self.iAgentList, j'ai ajouté des print comme vous m'avez demandé mais la sortie rien!!

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
 for infectAgent in infectList:
                self.eAgentList.remove(infectAgent)
                self.iAgentList.append(infectAgent)
                print('i',self.iAgentList)            
            recoverList = self.recoverAgents()
 
 for recoverAgent in recoverList:
                self.iAgentList.remove(recoverAgent)
                self.rAgentList.append(recoverAgent)                          
                print('r',self.rAgentList)

Donc j'ai modifié l'emplacement du print vers le haut

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
 
    def latentAgent(self,agent):
         self.sAgentList.remove(agent)
         latencyTime = self.t + scipy.random.exponential(1/self.e)
         heapq.heappush(self.latencyTimesHeap, (latencyTime, agent))
         print('e',self.eAgentList)
 
    def infectAgent(self,agent):
        self.eAgentList.remove(agent)         
 
        recoveryTime = self.t + scipy.random.exponential(1/self.g)
 
        heapq.heappush(self.recoveryTimesHeap, (recoveryTime, agent))
 
        return 1
        print('i',self.iAgentList)

Comme résultat, j'ai eu juste deux listes malgré que je recompile le programme plusieurs fois, la 1 ere est toujours vide et la 2 eme un numéro d'agent : [][x], je ne sais pas pourquoi les agents ne se déplacent pas de la classe E vers I!!
Merci

[VinsS]

Tout d'abord si tu n'as aucun retour avec les deux premiers print c'est que les boucles for infectAgent in infectList: et for recoverAgent in recoverList: ne sont pas exécutées, en d'autres termes, les listes infectList et recoverList sont vides.

Deuxième chose:

Code :

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

1
2
3
4
5
    def infectAgent(self,agent):
        ...

            for infectAgent in infectList:

... pas une bonne idée d'utiliser le même nom.

Ensuite:

Code :

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

1
2
3
4
5
6
 
    def latentAgent(self,agent):
         self.sAgentList.remove(agent)
         latencyTime = self.t + scipy.random.exponential(1/self.e)
         heapq.heappush(self.latencyTimesHeap, (latencyTime, agent))
         print('e',self.eAgentList)

vu le nombre d'inconnues, pour moi, que contient ce code, je serais bien incapable de dire ce qui peut être attendu du print mais je vois que la liste eAgentList n'est pas traitée dans cette fonction.

Et pour finir:

Code :

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

1
2
3
4
5
6
 
    def infectAgent(self,agent):
        ...
 
        return 1
        print('i',self.iAgentList)

ce print là est purement décoratif.

Pourrais-tu dresser un schéma du fonctionnement de ton code, ou, au moins des mutations des agents, que l'on aie une vue d'ensemble de la mécanique ?

[Anna69]

Bonjour,
Merci pour votre réponse,
Afin de mieux comprendre mon programme, je met a votre disposition 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
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
 
import igraph
import random
import copy
import pylab as pl
import scipy
from scipy import random
import heapq
import NetGraphics
 
#model constructor
class simpleNetworkSIRModel():
    def __init__(self, b  , e ,  g , S , E , p , nei):        
 
        #parameters
        self.b = b
        self.e = e
        self.g = g
        self.t = 0
        self.p = p
 
        self.N = S + E
 
        self.graph = igraph.Graph.Watts_Strogatz(1, self.N, nei=nei, p = p)
 
        self.graph.simplify()
 
        self.adjacencyList = []
        for i in range(self.N):
            self.adjacencyList.append([])
 
 
        for edge in self.graph.es: 
            self.adjacencyList[edge.source].append(edge.target) 
            self.adjacencyList[edge.target].append(edge.source) 
 
 
        self.sAgentList = []
        self.eAgentList = []
        self.iAgentList = []
        self.rAgentList = []
 
 
        self.sList = []
        self.eList = []
        self.iList = []
        self.rList = []
        self.newIList = []
 
 
        self.latencyTimesHeap = []
        self.recoveryTimesHeap = []
 
 
        allAgents = range(self.N)
 
        random.shuffle(allAgents)
 
        self.sAgentList = copy.copy(allAgents)
 
        # infecter quelques agents à t = 0
        self.indexCases = []
        for i in xrange(E):
            indexCase = self.sAgentList[0]
            self.indexCases.append(indexCase)
            self.latentAgent(indexCase)
            self.eAgentList.append(indexCase)
 
 
 
    def latentAgent(self,agent):
         self.sAgentList.remove(agent)
         latencyTime = self.t + scipy.random.exponential(1/self.e)
         heapq.heappush(self.latencyTimesHeap, (latencyTime, agent))
 
 
    def infectAgent(self,agent):
        self.eAgentList.remove(agent)         
 
        recoveryTime = self.t + scipy.random.exponential(1/self.g)
 
        heapq.heappush(self.recoveryTimesHeap, (recoveryTime, agent))
 
        return 1
 
    def recoverAgents(self):
 
        recoverList = []
        if len(self.recoveryTimesHeap) > 0:
            while self.recoveryTimesHeap[0][0] <= self.t:
                recoveryTuple = heapq.heappop(self.recoveryTimesHeap)
                recoverList.append(recoveryTuple[1])
                if len(self.recoveryTimesHeap) == 0:
                    break
 
        return recoverList
        print('r',self.rAgentList)
 
    def run(self):
        while len(self.eAgentList) > 0:
            tempEAgentList = []
            infectList = []
            recoverList = []
            newE = 0
            for eAgent in self.eAgentList:                
                for agent in self.adjacencyList[eAgent]:                   
                    if agent in self.sAgentList:
                        if (random.random() < self.b):                            
                            newE += self.latentAgent(agent)
                            tempEAgentList.append(agent)
 
 
 
            infectList = self.infectAgents()
 
            for infectAgent in infectList:
                self.eAgentList.remove(infectAgent)
                self.iAgentList.append(infectAgent)
                print('i',self.iAgentList)
 
            recoverList = self.recoverAgents()
 
            for recoverAgent in recoverList:
                self.iAgentList.remove(recoverAgent)
                self.rAgentList.append(recoverAgent)
 
                print('r',self.rAgentList)
 
            self.eAgentList.extend(tempEAgentList)
 
 
            self.sList.append(len(self.sAgentList))
            self.eList.append(len(self.eAgentList))
            self.iList.append(len(self.iAgentList))
            self.rList.append(len(self.sAgentList))
            self.newEList.append(newE)
 
            self.t += 1
            print('t', self.t, 'numS', len(self.sAgentList),'numE', len(self.eAgentList), 'numI', len(self.iAgentList) )
 
            random.shuffle(self.eAgentList)
 
 
        return [self.sList, self.eList, self.iList, self.rList, self.newIList]
 
 
if __name__=='__main__':
 
 
    #paramètres
    b = .002 
    e = .01
    g = .01 
 
    #condition initiale
    S = 500
    E = 2
 
    #paramètres du réseau
    p = .05 
    nei = 3
 
    myNetworkModel = simpleNetworkSIRModel(b = b, e = e, g = g, S = S, E = E, p = p, nei = nei)
    networkResults = myNetworkModel.run()
    numNetworkCases = sum(networkResults[3])
    pl.figure()
    pl.plot(networkResults[1], label = 'Evolution d epidemie dans le reseau; ' + str(numNetworkCases) + ' cas')
    pl.plot(allAgents)
    pl.xlabel('temps')
    pl.ylabel('Nbr Infectes')

Merci

[wiztricks]

Salut,

Si la liste "self.iAgentList" reste vide il faut regarder comment elle se remplit:

Code :

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

1
2
3
4
5
6
            infectList = self.infectAgents()
 
            for infectAgent in infectList:
                self.eAgentList.remove(infectAgent)
                self.iAgentList.append(infectAgent)
                print('i',self.iAgentList)

Dit autrement, tout ce que retourne self.infectAgents() devrait se retrouver dans self.iAgentList.
Or:

Code :

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

1
2
3
4
5
6
7
8
    def infectAgent(self,agent):
        self.eAgentList.remove(agent)         
 
        recoveryTime = self.t + scipy.random.exponential(1/self.g)
 
        heapq.heappush(self.recoveryTimesHeap, (recoveryTime, agent))
 
        return 1

Vu que cette méthode ne retourne même pas une liste, votre code devrait se vautrer grave:

Code :

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

1
2
3
4
5
6
>>> for z in 1: print ('foo')
...
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'int' object is not iterable
>>>

A part vous qui peut savoir comment construire ce (la liste) que devrait retourner cette fonction/méthode?
Comment avez vous testé cette méthode pour vous assurer qu'elle fait a peu près ce qu'on attend d'elle?

- W

[VinsS]

Peux pas tester, le paquet debian python-igraph est manifestement bugué.

En plus de ce que dit Wiztricks, je m'étonne que tu puisse faire tourner ton code, tu devrais avoir une erreur ici:

Code :

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

1
2
 
    def infectAgent(self,agent):

fonction qui est appelée plus loin:

Code :

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

1
2
 
            infectList = self.infectAgents()

Il manque le "s" au nom de la fonction et l'argument à l'appel.

[Anna69]

Bonjour
Merci pour vos réponses,
Pour Wiztricks, svp je ne comprend pas" Vu que cette méthode ne retourne même pas une liste", parlez-vous du code ou de mes sorties?
J'ai modifié l'appel selon la proposition de VinsS, normalement c'est logique mais j'ai eu comme sortie de compilation:

Code :

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

1
2
3
4
5
6
 
Traceback (most recent call last):
 in <module> networkResults = myNetworkModel.run()
 in run  infectList = self.infectAgent(agent)
  in infectAgent  self.eAgentList.remove(agent)
ValueError: list.remove(x): x not in list

Afin de trouver une solution a mon programme, j'explique cette partie. Au départ, on suppose que tous les agents sont dans la liste "self.sAgentList" , on infecte quelques uns qui passent de la liste "self.sAgentList" a la liste "self.eAgentList" et qui vont par la suite assurer la transmission de l'infection via leurs voisins (dans la fonction run). Pour cela, on définit 3 fonctions:
Pour remplir la liste "self.eAgentList", j'utilise la fonction:

Code :

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

1
2
3
4
5
6
 
  def latentAgent(self,agent):
         self.sAgentList.remove(agent)
         latencyTime = self.t + scipy.random.exponential(1/self.e)
         heapq.heappush(self.latencyTimesHeap, (latencyTime, agent))
       #  print('e',self.eAgentList)

Pour remplir la liste "self.iAgentList", j'utilise la fonction:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
   def infectAgent(self,agent):
        self.eAgentList.remove(agent)         
 
        #Distribution expo pour recovery time
        recoveryTime = self.t + scipy.random.exponential(1/self.g)
 
        heapq.heappush(self.recoveryTimesHeap, (recoveryTime, agent))
 
        return 1
        print('i',self.iAgentList)

Pour remplir la liste "self.rAgentList", j'utilise la fonction:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
   def recoverAgents(self):
        recoverList = []
        if len(self.recoveryTimesHeap) > 0:
            while self.recoveryTimesHeap[0][0] <= self.t:
 
                recoveryTuple = heapq.heappop(self.recoveryTimesHeap)
                recoverList.append(recoveryTuple[1])
                if len(self.recoveryTimesHeap) == 0:
                    break
 
        return recoverList
     #   print('r',self.rAgentList)

Puis la simulation se fait par la fonction suivante:

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
 
   def run(self):
        #comme while E > 0
        while len(self.eAgentList) > 0:
            tempEAgentList = []
            infectList = []
            recoverList = []
            newE = 0
            #nous avons bouclé sur les agents qui sont actuellement exposé
            for eAgent in self.eAgentList:
                #puis exposer leurs voisins du graphe
                for agent in self.adjacencyList[eAgent]:
                    #Etant donné un voisin susceptible
                    if agent in self.sAgentList:
                        if (random.random() < self.b):                           
                            newE += self.latentAgent(agent)
                            tempEAgentList.append(agent)
 
 
            infectList = self.infectAgent(agent) # appel de la fonction 
 
            for infectAgent in infectList:    # obtention de la liste des infectés
                self.eAgentList.remove(infectAgent)
                self.iAgentList.append(infectAgent)
                print('i',self.iAgentList)
            #obtention de la liste des  guéris
            recoverList = self.recoverAgents()
 
            for recoverAgent in recoverList:
                self.iAgentList.remove(recoverAgent)
                self.rAgentList.append(recoverAgent)
 
                print('r',self.rAgentList)
 
            self.eAgentList.extend(tempEAgentList)
 
            #puis suivre le nombre de personnes dans chaque Etat
            self.sList.append(len(self.sAgentList))
            self.eList.append(len(self.eAgentList))
            self.iList.append(len(self.iAgentList))
            self.rList.append(len(self.sAgentList))
            self.newEList.append(newE)
 
            #incrementation du temps
            self.t += 1
            print('t', self.t, 'numS', len(self.sAgentList),'numE', len(self.eAgentList), 'numI', len(self.iAgentList) )
 
            random.shuffle(self.eAgentList)
 
        return [self.sList, self.eList, self.iList, self.rList, self.newIList]

Je précise que chaque s.agent passe a la liste e.agent soit parce qu'il est infecté au départ, soit parce qu'il est infecté dans la simulation par leurs voisins. il reste un temps 'latencytime' dans cette liste "self.eAgentList" puis il passent a la liste "self.iAgentList"ou il reste une période 'recoverytime' en suite, il passe a la liste "self.rAgentList".

Je vous remercie pour vos efforts

[VinsS]

Tout d'abord rajoute ce print ici:

Code :

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

1
2
3
4
5
6
7
8
 
        for i in xrange(E):
            indexCase = self.sAgentList[0]
            self.indexCases.append(indexCase)
            self.latentAgent(indexCase)
            self.eAgentList.append(indexCase)
 
        print('eAgentList:', self.eAgentList) # Doit contenir deux objets

Si je suis bien ton code, self.eAgentList doit contenir les deux premiers objets de self.sAgentList

Ensuite, tu as ceci:

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
 
    def infectAgent(self,agent):
        print('agent:', agent) # + ce print
        self.eAgentList.remove(agent)         
        recoveryTime = self.t + scipy.random.exponential(1/self.g)
        heapq.heappush(self.recoveryTimesHeap, (recoveryTime, agent))
        return 1
 
    ...
 
    def run(self):
        while len(self.eAgentList) > 0:
            tempEAgentList = []
            infectList = []
            recoverList = []
            newE = 0
            for eAgent in self.eAgentList:                
                for agent in self.adjacencyList[eAgent]:          #  <------------------------|
                    if agent in self.sAgentList:                  #                           |
                        if (random.random() < self.b):            #                           |
                            newE += self.latentAgent(agent)       #                           |
                            tempEAgentList.append(agent)          #                           |
                                                                  #                           |
            infectList = self.infectAgent(agent) # agent = le dernier agent de cette boucle --|
 
            print('infectList:', infectList) # Rajoute encore ce print

La fonction infectAgent() retourne 1 alors que tu attend une liste mais quelle liste ?

[Anna69]

Salut
Merci pour votre réponse rapide,
J'ai ajouté des print ou vous m'avez demandé, voici la sortie:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
('eAgentList:', [216])
('eAgentList:', [216, 130])
('agent:', 133)
 
Traceback (most recent call last):
   in <module>
    networkResults = myNetworkModel.run()
 in run
    infectList = self.infectAgent(agent)
 in infectAgent
    self.eAgentList.remove(agent)
ValueError: list.remove(x): x not in list

pour le retour 1 j'attend la liste des infectés!
Merci

[VinsS]

Comme tu vois la liste initiale contient deux objets et l'agent transmit à la fonction n'y est pas.

En fait l'agent en question provient de la liste adjacencyList qui, je suppose est la liste des cellules voisines de eAgent.

De cette manière, cela me paraît plus logique:

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
 
    def infectAgent(self, agent):       
        recoveryTime = self.t + scipy.random.exponential(1/self.g)
        heapq.heappush(self.recoveryTimesHeap, (recoveryTime, agent))
 
    def recoverAgents(self):
        recoverList = []
        if len(self.recoveryTimesHeap) > 0:
            while self.recoveryTimesHeap[0][0] <= self.t:
                recoveryTuple = heapq.heappop(self.recoveryTimesHeap)
                recoverList.append(recoveryTuple[1])
                if len(self.recoveryTimesHeap) == 0:
                    break
 
        return recoverList
 
    def run(self):
        while len(self.eAgentList) > 0:
            tempEAgentList = []
            infectList = []
            recoverList = []
            newE = 0
            for eAgent in self.eAgentList:             
                for agent in self.adjacencyList[eAgent]:                   
                    if agent in self.sAgentList:
                        if (random.random() < self.b):                            
                            newE += self.latentAgent(agent)
                            tempEAgentList.append(agent)
                            self.infectAgent(eAgent)
                            infectList.append(eAgent)
 
            print('infectList:', infectList)
 
            for infectAgent in infectList:
                self.eAgentList.remove(infectAgent)
                self.iAgentList.append(infectAgent)
                print('iAgentList:',self.iAgentList)
 
            recoverList = self.recoverAgents()

D'où provient ce code au départ ?

[Anna69]

Salut,
les sorties de ce code:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
('eAgentList:', [27])
('eAgentList:', [27, 451])
('infectList:', [])
 
Traceback (most recent call last):
 , in <module>
    networkResults = myNetworkModel.run()
in run
    self.newEList.append(newE)
AttributeError: simpleNetworkSIRModel instance has no attribute 'newEList'

Je pense qu'il faut insérer ce code en quelque part dans 'def infectAgent(self, agent):', car il permettra la préparation de l'agent e.agent de la liste "eAgentList"pour passer a la liste "iAgentList":

Code :

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

1
2
 
 self.sAgentList.remove(agent)

La source de ce code: https://gist.github.com/jzelner/234127
L'auteur utilise ici 3 classes S,I,R et pour moi j'ajoute une nouvelle classe entre S et I :classe E
Merci

[VinsS]

C'est beaucoup plus clair avec les commentaires.

Donc, si je comprend bien, tu veux introduire un état supplémentaire aux agents, un stade de latence.

Première source d'erreur, tu utilises la lettre e pour ce nouvel état et tu modifies les e du code original en i.
Çà a l'air très banal, vu comme ça, mais c'est la cause de ta dernière erreur: self.newEList >> self.newIList et probablement d'erreurs précédentes.

Tu devrais utiliser les lettres l et L pour ce nouvel état afin d'éviter les confusions de listes.

Je pense que comme ceci les erreurs de listes devraient être évitées.

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
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
 
# -*- coding: utf-8 -*-
import igraph
import random
import copy
import pylab as pl
import scipy
from scipy import random
import heapq
 
#model constructor
class simpleNetworkSIRModel():
    def __init__(self, b  , e ,  g , S , E , p , nei):        
        #parameters
        self.b = b
        self.e = e
        self.g = g
        self.t = 0
        self.p = p
        self.N = S + E 
        self.graph = igraph.Graph.Watts_Strogatz(1, self.N, nei=nei, p = p)
        self.graph.simplify()
        self.adjacencyList = []
        for i in range(self.N):
            self.adjacencyList.append([])
 
        for edge in self.graph.es: 
            self.adjacencyList[edge.source].append(edge.target) 
            self.adjacencyList[edge.target].append(edge.source) 
 
        self.sAgentList = []
        self.eAgentList = []
        self.iAgentList = []
        self.rAgentList = []
 
        self.sList = []
        self.eList = []
        self.iList = []
        self.rList = []
        self.newIList = []
 
        self.latencyTimesHeap = []
        self.recoveryTimesHeap = []
 
        allAgents = range(self.N)
        random.shuffle(allAgents)
        self.sAgentList = copy.copy(allAgents)
 
        # infecter quelques agents à t = 0
        self.indexCases = []
        for i in xrange(E):
            indexCase = self.sAgentList[0]
            self.indexCases.append(indexCase)
            self.latentAgent(indexCase)
            self.eAgentList.append(indexCase)
 
        print('eAgentList:', self.eAgentList) # Doit contenir deux objets
 
    def latentAgent(self,agent):
        self.sAgentList.remove(agent)
        latencyTime = self.t + scipy.random.exponential(1/self.e)
        heapq.heappush(self.latencyTimesHeap, (latencyTime, agent))
        return 1
 
    def infectAgent(self, agent):       
        recoveryTime = self.t + scipy.random.exponential(1/self.g)
        heapq.heappush(self.recoveryTimesHeap, (recoveryTime, agent))
 
    def recoverAgents(self):
        recoverList = []
        if len(self.recoveryTimesHeap) > 0:
            while self.recoveryTimesHeap[0][0] <= self.t:
                recoveryTuple = heapq.heappop(self.recoveryTimesHeap)
                recoverList.append(recoveryTuple[1])
                if len(self.recoveryTimesHeap) == 0:
                    break
 
        return recoverList
 
    def run(self):
        while len(self.eAgentList) > 0:
            tempEAgentList = []
            infectList = []
            recoverList = []
            newE = 0
            for eAgent in self.eAgentList:             
                for agent in self.adjacencyList[eAgent]:                   
                    if agent in self.sAgentList:
                        if (random.random() < self.b):                            
                            newE += self.latentAgent(agent)
                            tempEAgentList.append(agent)
 
                self.infectAgent(eAgent)
                infectList.append(eAgent)
 
            print('infectList:', infectList)
 
            for infectAgent in infectList:
                self.eAgentList.remove(infectAgent)
                self.iAgentList.append(infectAgent)
                print('iAgentList:',self.iAgentList)
 
            recoverList = self.recoverAgents()
 
            for recoverAgent in recoverList:
                self.iAgentList.remove(recoverAgent)
                self.rAgentList.append(recoverAgent)
                print('r',self.rAgentList)
 
            self.eAgentList.extend(tempEAgentList)
            self.sList.append(len(self.sAgentList))
            self.eList.append(len(self.eAgentList))
            self.iList.append(len(self.iAgentList))
            self.rList.append(len(self.sAgentList))
            self.newIList.append(newE)
 
            self.t += 1
            print('t', self.t, 'numS', len(self.sAgentList),'numE', 
                  len(self.eAgentList), 'numI', len(self.iAgentList) )
            random.shuffle(self.eAgentList)
 
        return [self.sList, self.eList, self.iList, self.rList, self.newIList]
 
 
if __name__=='__main__':
    #paramètres
    b = .002 
    e = .01
    g = .01 
    #condition initiale
    S = 500
    E = 2
    #paramètres du réseau
    p = .05 
    nei = 3
    myNetworkModel = simpleNetworkSIRModel(b, e, g, S, E, p, nei)
    networkResults = myNetworkModel.run()
    numNetworkCases = sum(networkResults[3])
    pl.figure()
    pl.plot(networkResults[1], label = 'Evolution d epidemie dans le reseau; ' + str(numNetworkCases) + ' cas')
    pl.plot(allAgents)
    pl.xlabel('temps')
    pl.ylabel('Nbr Infectes')

Pas testé ...

[Anna69]

Salut,
Merci beaucoup, mieux qu'avant! juste là il y'a un problème d'incrémentation du temps, l'affichage se fait juste pour le t1, ce qui empêche l'affichage du graphe dans le temps
Sortie de compilation:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
('eAgentList:', [159, 10])
('infectList:', [159, 10])
('iAgentList:', [159])
('iAgentList:', [159, 10])
('t', 1, 'numS', 500, 'numE', 0, 'numI', 2)
 
Traceback (most recent call last):
  in <module>
    pl.plot(allAgents)
NameError: name 'allAgents' is not defined

En plus, la liste de E normalement doit être rempli avant la liste des I, or dans la sortie à t1 numE=0 et numI=2!!
Merci

[VinsS]

allAgent n'est qu'une liste d'entiers de 0 à 502 (S + E) mélangée avec random.shuffle, si tu en as absolument besoin hors de la classe il faut que tu en gardes référence.

Comme ceci:

Code :

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

1
2
3
4
5
6
7
 
        self.allAgents = range(self.N)
        random.shuffle(self.allAgents)
        self.sAgentList = copy.copy(self.allAgents)
 
...
    pl.plot(myNetworkModel.allAgents)

et eAgentList est vidée par:

Code :

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

1
2
3
4
 
            for infectAgent in infectList:
                self.eAgentList.remove(infectAgent)
                self.iAgentList.append(infectAgent)

Je ne m'étonne pas qu'elle soit vide.

[Anna69]

Salut,
Merci, mais il y'a un problème, voici le sortie de compilation après les modifications proposées:

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
 
('eAgentList:', [151, 269, 361, 219, 485, 424, 164, 54, 157, 262])
('infectList:', [151, 269, 361, 219, 485, 424, 164, 54, 157, 262])
('iAgentList:', [151])
('iAgentList:', [151, 269])
('iAgentList:', [151, 269, 361])
('iAgentList:', [151, 269, 361, 219])
('iAgentList:', [151, 269, 361, 219, 485])
('iAgentList:', [151, 269, 361, 219, 485, 424])
('iAgentList:', [151, 269, 361, 219, 485, 424, 164])
('iAgentList:', [151, 269, 361, 219, 485, 424, 164, 54])
('iAgentList:', [151, 269, 361, 219, 485, 424, 164, 54, 157])
('iAgentList:', [151, 269, 361, 219, 485, 424, 164, 54, 157, 262])
('t', 1, 'numS', 499, 'numE', 1, 'numI', 10, 'numR', 0)
('infectList:', [421])
('iAgentList:', [151, 269, 361, 219, 485, 424, 164, 54, 157, 262, 421])
('t', 2, 'numS', 510, 'numE', 0, 'numI', 11, 'numR', 0)

Or normalement, dans le temps on doit avoir le nombre de E initial diminue avec une l'augmentation de le nombre de I (c-a-d les agents sort de la classe E vers I puis vers R) et même le nombre R ici égale a 0!! je pense que les agents de E rentre aussi dans 'infectList' dans le run
Merci

[Anna69]

Je remarque aussi que la valeur de S doit être <= 500 pendant la simulation!
a+

[Anna69]

Bonjour,
J'ai pu corriger quelques étapes dans le programme, il me reste juste cette étape que je n'arrive pas a la résoudre, SVP de m'aider!
En fait, dans le code ci-dessous, il existe un problème avec le remplissage de la liste self.eAgentList, dans mon programme je donne une valeur initiale a E pour que durant le run j'aurai la liste E + new E, or cette valeur est prise par self.iAgentList et self.eAgentList prend juste la valeur de newE, j'ai essayé de supprimer tempEAgentList et la remplacer par self.eAgentList dans ce qui suit mais ça n'a pas marché.

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
 
   def run(self):
        while len(self.eAgentList) > 0:
            tempEAgentList = []
            infectList = []
            recoverList = []
            newE = 0
            for eAgent in self.eAgentList:             
                for agent in self.adjacencyList[eAgent]:                   
                    if agent in self.sAgentList:
                        if (random.random() < self.b):                            
                            newE += self.latentAgent(agent)
                            print('newE:', newE)
                            tempEAgentList.append(agent)
                            print('tempEAgentList:', tempEAgentList)
                self.infectAgent(eAgent)
                infectList.append(eAgent)
 
                print('infectList:', infectList)
 
            for infectAgent in infectList:
                self.eAgentList.remove(infectAgent)
                self.iAgentList.append(infectAgent)
 #               print('iAgentList:',self.iAgentList)
 
 
            recoverList = self.recoverAgents()
 
            for recoverAgent in recoverList:
                self.iAgentList.remove(recoverAgent)
                self.rAgentList.append(recoverAgent)
             #   print('r',self.rAgentList)
 
            self.eAgentList.extend(tempEAgentList)
            self.sList.append(len(self.sAgentList))
            self.eList.append(len(self.eAgentList))
            self.iList.append(len(self.iAgentList))
            self.rList.append(len(self.sAgentList))
            self.newIList.append(newE)
 
            self.t += 1
            print('t', self.t, 'numS', self.sAgentList,'numE', self.eAgentList, 'numI', self.iAgentList, 'numR', self.rAgentList )
            #random.shuffle(self.eAgentList)
            self.allAgents = range(self.N)
            #random.shuffle(self.allAgents)
           # self.sAgentList = copy.copy(self.allAgents)
           # random.shuffle(self.eAgentList)
 
        return [self.sList, self.eList, self.iList, self.rList, self.newIList]

Juste pour vous informer le code au dessus est correct (vérifier par des print).
A mon avis le souci est dans le retour ou j'ai de nouveau E mais je perd le nombre de E initiale :

Code :

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

1
2
3
4
5
 
                            newE += self.latentAgent(agent)
                            print('newE:', newE)
                            tempEAgentList.append(agent)
                            print('tempEAgentList:', tempEAgentList)

Vous en remerciant

[wiztricks]

Salut,

Le bout de code que vous montrez devrait pouvoir fonctionner en y ajoutant le minimum pour emballer la méthode "run" dans une classe et en mettant dans __init__ l'initialisation des objets référencés par "self.".
Exemple:

Code :

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

1
2
3
4
5
6
7
class Test:
      def __init__(self, eAgentList, adjacencyList, ...):
           self.eAgentList = eAgentList
           self.adjacencyList = adjacencyList
           ...
       def run(self):
           ... votre code ...

Le but étant de pouvoir "lancer" la chose sur des cas précis, i.e. écrire par exemple une fonction:

Code :

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

1
2
3
4
5
6
7
def test_case():
      # initialisation
      eAgentList = ....
      ...
      test = Test(eAgentList, ...)
      results = test.run()
      # est-ce que results contient ce qu'on attend

Si vous ne faites pas çà, pas facile de comprendre ce que vous attendez.
Ce que vous racontez en français mélange votre métier, des choix de programmation,...
Le tout produisant un truc incompréhensible sinon d'exprimer "à l'aide".
Comme nous n'avons même pas un code "fonctionnel" pour essayer d'accrocher ces mots à une réalité "palpable"...
Pas facile de "comprendre", ce qui est préalable à essayer de vous aider.

- W

[Anna69]

Bonsoir,
Très bonne idée, ca marche, Merci Wiztricks
Un grand merci également a VinsS, il m'a beaucoup aider dans ce programme et a développez.net