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