JIM2021-1 - Modélisation discrète d'une épidémie

Journée Internationale des Mathématiques 2021
Modélisation discrète d'une épidémie
Clément Boulonne (CBMaths)
14 mars 2021
Clément Boulonne (CBMaths) Modélisation d'une épidémie 14 mars 2021 1/65

Sommaire
1 Éléments préliminaires
Population
Rencontre et jours de modélisation
Virus et état des personnes
2 Sain/infecté
Mise en place
Résultats et espérance
Évolution et calcul de probabilités
3 États supplémentaires après l'infection
4 Eets de la vaccination

Introduction
On s'intéresse à la propagation d'un
virus dans un groupe de 100
personnes. Ce virus se transmet
(avec une probabilité p, p étant un
nombre réel compris entre 0 et 1) à
une personne saine si elle rencontre
une personne infectée.
On construira pas à pas un
programme en Python pour
modéliser la propagation du virus
dans la population.

Éléments préliminaires
Sommaire
2 Sain/infecté

Éléments préliminaires Population
Sommaire
Population
2 Sain/infecté
Mise en place

Modélisation de la population
Le groupe de 100 personnes sera représenté dans notre programme
Python par une liste de 100 éléments numériques.

Pour construire une liste de n éléments, on tape le code suivant :
L = [0 for i in range(n+1)]
sachant que i in range(n) fait prendre à la variable i les valeurs de
0 à n − 1.

Pour construire une liste de n éléments, on tape le code suivant :
L = [0 for i in range(n+1)]
sachant que i in range(n) fait prendre à la variable i les valeurs de
0 à n − 1.
Si on ne xe pas la valeur de n, on peut la demander à l'utilisateur au
début avec les lignes de code suivant :
print Population
n = int(input ())

Temps d'exécution
Des tests d'exécution ont été eectués sur la calculatrice Numworks
qui permet de programmer en Python.

Temps d'exécution
Des tests d'exécution ont été eectués sur la calculatrice Numworks
qui permet de programmer en Python.
On peut calculer le temps d'exécution d'un programme Python en
utilisant le module time et en l'implémentant dans le programme
comme suivant.
from time import *
start=monotonic ()
programme
end=monotonic ()
print(time:,end -start)

Temps d'exécution
Ici, on teste le temps d'exécution de ce programme.
from time import *
start=monotonic ()
L=[0 for i in range(n)]
end=monotonic ()

Temps d'exécution
Ici, on teste le temps d'exécution de ce programme.
from time import *
start=monotonic ()
L=[0 for i in range(n)]
end=monotonic ()
Voici les résultats avec diérentes valeurs de n.
n 100 250 500 1000
time (en s) 0,003 0,008 0,008 0,011
n 2000 3000 4000 5000
time (en s) 0,016 0,020 0,024 MemoryError

Remarques
1 La génération d'une liste avec beaucoup d'éléments est très rapide sur
la calculatrice.

Remarques
la calculatrice.
2 Par contre, on ne peut pas excéder 212 = 4096 éléments dans la liste.

Remarques
la calculatrice.
2 Par contre, on ne peut pas excéder 212 = 4096 éléments dans la liste.
3 Conclusion : on choisit de xer la valeur de n à 100 dans tout l'exposé.

Éléments préliminaires Rencontre et jours de modélisation
Sommaire
Population
2 Sain/infecté
Mise en place

Dénition d'une rencontre
Rencontre
Une rencontre est une interaction avec deux personnes.
Dans le programme Python, on dira plutôt que c'est une interaction entre
deux éléments distincts de la liste.

Programmation
Pour programmer une rencontre, on prendra deux entiers i et j
aléatoirement compris entre 0 et 99 (range(100)).

Programmation
On aura donc besoin du module random.
from random import *
L=[0 for k in range (100)]
i=randint (0,99)
j=randint (0,99)
print(i,j)

Programmation
On aura donc besoin du module random.
i=randint (0,99)
j=randint (0,99)
print(i,j)
On peut avoir ces résultats en sortie.
65 75

Programmation
Mais il se peut que les entiers i et j choisis soient égaux.
36 36

Programmation
36 36
Cela peut arriver avec une probabilité de
1
100
.

Programmation
36 36
Cela peut arriver avec une probabilité de
1
100
.
Ainsi, il faut ajouter une modication à la génération des entiers i et j :
i=randint (0,99)
j=randint (0,99)
while i==j:
j=randint (0,99)
print i,j

Jours de modélisation
Tout au long de l'exposé, on verra qu'une rencontre est un élément
fondamental pour la modélisation.

Mais si on attend que toute la population soit contaminée par le virus,
il faudra attendre des milliers et des milliers de rencontres pour
parvenir à nos ns.

parvenir à nos ns.
Pour simplier l'écriture des résultats, on va regrouper les rencontres
en paquets de 500 (ou pour un n quelconque, on les regroupera en
paquets de 5 × n rencontres) qu'on appellera jour de modélisation.

parvenir à nos ns.
Jour de modélisation
Si la population est constituée de n individus, on appelle jour de
modélisation, un ensemble de 5n rencontres.

parvenir à nos ns.
Jour de modélisation
Si la population est constituée de n individus, on appelle jour de
modélisation, un ensemble de 5n rencontres.
Par exemple, si la population a été entièrement infectée après 14921
rencontres, on dira que la modélisation aura durée 30 jours car
500 × 29 6 14921 6 500 × 30 .

Éléments préliminaires Virus et état des personnes
Sommaire
Population
2 Sain/infecté
Mise en place

Eet du virus sur une rencontre
Dans l'introduction de l'exposé,
nous avons indiqué que le virus
infecte une nouvelle personne si elle
rencontre une personne déjà
infectée. Elle est infectée avec une
probabilité p (0 6 p 6 1).

Eet du virus sur une rencontre
Dans l'introduction de l'exposé,
nous avons indiqué que le virus
infecte une nouvelle personne si elle
rencontre une personne déjà
infectée. Elle est infectée avec une
probabilité p (0 6 p 6 1).
Probabilité d'infection
Si une personne saine a une probabilité p (0 6 p 6 1) d'être infectée par le
virus lorsqu'elle rencontre une personne infectée alors on dira que le virus a
une probabilité d'infection égale à p.

État des personnes
Pour identier les personnes infectées avec les personnes saines, il
faudra dénir leurs états et comment les représenter dans la liste en
Python.

État des personnes
Python.
0 : la personne n'est pas infectée (on dira aussi qu'elle est saine);

État des personnes
Python.
1 : la personne est infectée.

État des personnes
Python.
Pour complexier le problème et pour coller au réalisme de la
modélisation dans la vie de tous les jours , on devra ajouter
d'autres états.

État des personnes
Python.
d'autres états.
personne guérie du virus;

État des personnes
Python.
d'autres états.
personne morte du virus;

État des personnes
Python.
d'autres états.
personne vaccinée.

État des personnes
Python.
d'autres états.
personne vaccinée.
Dans le programme, on verra par la suite comment représenter chaque
état dans la liste.

Sain/infecté
Sommaire
2 Sain/infecté

Sain/infecté Mise en place
Sommaire
Population
2 Sain/infecté
Mise en place

Explication de la modélisation
On dispose d'une population de 100 habitants et un virus qui a une
probabilité de contamination p.

Au départ, au jour 0 de la modélisation, 100 × p personnes sont
aléatoirement infectées par le virus (si ce nombre est un nombre non
entier, on arrondira à l'entier supérieure).

Si une personne saine rencontre une personne saine, il n'y a pas de
nouvelle contamination à l'issue de la rencontre.

Si une personne infectée rencontre une personne infectée, il n'y a pas
de nouvelle contamination à l'issue de la rencontre.

Si une personne infectée rencontre une personne infectée, il n'y a pas
de nouvelle contamination à l'issue de la rencontre.
Si une personne saine rencontre une personne infectée, la personne
saine a une probabilité p de se faire contaminée et de passer en
personne infectée.

Implémentation dans le programme
On dispose de deux variables n=100 (population) et pcont (la
probabilité de contamination du virus). On prendra comme valeur 0,03
pour pcont pour l'explication de l'implémentation.

On créé la liste L de population (comme expliqué dans les
préliminaires) et on fait passer en état contaminé (état 1) 30
personnes (plus généralement ceil(pconf*n)) en n'oubliant pas de
mettre une boucle while si par mégarde on choisit une personne déjà
contaminée avant la n de l'opération. Le passage d'état est symbolisé
par l'instruction L[x]=1 après la boucle while.

Remarque : la fonction ceil permet d'arrondir le nombre à l'entier
supérieur et nécessite l'implémentation du module math.

Remarque : la fonction ceil permet d'arrondir le nombre à l'entier
supérieur et nécessite l'implémentation du module math.
On créé deux variables i et s qui compte le nombre de personnes
infectées et saines dans la population à un jour j donné.

Début de la programmation
Le début de notre programme en Python ressemble à ça :
from math import *
n=100
pcont =0.03
L=[0 for k in range(n)]
for k in range(ceil(pcont*n)):
x=randint(0,n-1)
while L[x]==1:
x=randint(0,n-1)
L[x]=1
j=0
i=L.count (1)
s=n-i
print(i,s)

Finalité de la modélisation
Le programme se terminera lorsque toute la population soit infectée
par le virus. La condition d'arrêt est donc i = 100 (ou en Python :
i==100).

i==100).
Pour simuler une rencontre, on choisit deux entiers x et y diérents
compris entre 0 et 100 (voir préliminaires).

i==100).
Si les deux personnes ont même état, c'est-à-dire L[x]==L[y] alors il
ne se passe rien.

i==100).
ne se passe rien.
Par contre, si les deux personnes ont deux états diérents
(saines/infectés) L[x]!=L[y] alors la personne saine est infectée avec
une probabilité p (ou pcont). Pour rappel : != signie 6= en Python.

i==100).
ne se passe rien.
Par contre, si les deux personnes ont deux états diérents
(saines/infectés) L[x]!=L[y] alors la personne saine est infectée avec
une probabilité p (ou pcont). Pour rappel : != signie 6= en Python.
Pour savoir si la personne saine sera contaminée, on tire au hasard un
nombre cont aléatoire entre 0 et 1 et si ce nombre est inférieur à
pcont, la personne saine sera dénitivement contaminée. Pour éviter
de programmer une boucle if, on utilisera les instructions simples
L[x]=1;L[y]=1.

Suite de la programmation
On incorpore les éléments de programmation dans le code :*
while i!=n:
for k in range (5*n):
x=randint(0,n-1)
y=randint(0,n-1)
while x==y:
y=randint(0,n-1)
if L[x]!=L[y]:
cont=random ()
if cont =pcont:
L[x]=1
L[y]=1
j=j+1
i=L.count (1)
s=n-i
print( Nombre de jours :,j)

Transformation en fonctions
Comme on va utiliser tout ce code pour la modélisation, on peut
l'inscrire sur des fonctions que l'on va appeler pour réaliser des tests.

Comme on va utiliser tout ce code pour la modélisation, on peut
l'inscrire sur des fonctions que l'on va appeler pour réaliser des tests.
On créé d'abord une fonction continit(n,pinf) qui initialise la
contamination du virus (contamination de probabilité pinf) dans une
population de n habitants
def continit(n,pcont):
global L
L=[0 for k in range(n)]
for k in range(ceil(pcont*n)):
x=randint(0,n-1)
while L[x]==1:
x=randint(0,n-1)
L[x]=1

Puis une autre fonction jour(n,pcont) qui permet de modéliser une
journée de contamination pour un virus d'une probabilité d'infection
égale à pcont et une population de n habitants.
def jour(n,pcont):
x=randint(0,n-1)
y=randint(0,n-1)
while x==y:
y=randint(0,n-1)
if L[x]!=L[y]:
cont=random ()
if cont =pcont:
L[x]=1
L[y]=1

Puis une autre fonction jour(n,pcont) qui permet de modéliser une
journée de contamination pour un virus d'une probabilité d'infection
égale à pcont et une population de n habitants.
def jour(n,pcont):
x=randint(0,n-1)
y=randint(0,n-1)
while x==y:
y=randint(0,n-1)
if L[x]!=L[y]:
cont=random ()
if cont =pcont:
L[x]=1
L[y]=1
La n du programme initialisera les variables nécessaires et fera appel
aux fonctions précédemment construite.

Sain/infecté Résultats et espérance
Sommaire
Population
2 Sain/infecté
Mise en place

Résultats de la modélisation
On teste le programme pour des valeurs de variables n=100 et
pconf=0.03. Les variables de sortie donnent le nombre de jours de
modélisation au bout duquel toute la population a été contaminée (ou
encore quand tous les éléments de la liste L vaut 1).

Résultats de la modélisation
On teste le programme pour des valeurs de variables n=100 et
pconf=0.03. Les variables de sortie donnent le nombre de jours de
modélisation au bout duquel toute la population a été contaminée (ou
encore quand tous les éléments de la liste L vaut 1).
Voici quelques exécutions :
Nombre de jours : 26

Quelques remarques
1 Le nombre de jours de modélisation uctue entre 25 et 32.

Quelques remarques
2 On peut se demander quelles sont les inuences des variables n et
pconf sur les résultats.

Quelques remarques
2 On peut se demander quelles sont les inuences des variables n et
pconf sur les résultats.
3 Pour cela, on va faire un programme que l'on va lancer 100 fois et qui
renvoie le nombre de jours moyen de modélisation sur les 100
simulations.

Espérance, programme
On va faire tourner le programme suivant.
n=100 # A MODIFIER
pcont =0.75 # A MODIFIER
jsum=0
for k in range (100):
continit(n,pcont)
i=L.count (1)
s=n-i
while i!=n:
jour(n,pcont)
jsum=jsum+1
i=L.count (1)
s=n-i
jmoy=jsum /100
print ( Nombre de jours moyen :,jmoy)

Espérance, inuence de n
On teste le programme avec
diérentes valeurs de n, avec
une valeur de pconf égale à
0,03.
n jmoy
100 30,02
250 32,19
500 34,52
1000 37,36
2000 39,27
4000 41,59

0,03.
Rappel : la variable n doit être
inférieure ou égale à 4096.
n jmoy
100 30,02
250 32,19
500 34,52
1000 37,36
2000 39,27
4000 41,59

0,03.
Quelques remarques sur les
exécutions et leurs résultats :
n jmoy
100 30,02
250 32,19
500 34,52
1000 37,36
2000 39,27
4000 41,59

0,03.
1 Le nombre de jours moyen a
une croissance logarithmique
par rapport à la valeur de n.
On a la formule suivante :
jmoy(n) ≈ 3,21ln(n)+14,82.
n jmoy
100 30,02
250 32,19
500 34,52
1000 37,36
2000 39,27
4000 41,59

0,03.
1 Le nombre de jours moyen a
une croissance logarithmique
par rapport à la valeur de n.
On a la formule suivante :
jmoy(n) ≈ 3,21ln(n)+14,82.
2 Plus la valeur de n est élevée,
plus le temps d'exécution du
programme est élevée
(croissance linéaire).
n jmoy
100 30,02
250 32,19
500 34,52
1000 37,36
2000 39,27
4000 41,59

Espérance, inuence de pconf
diérentes valeurs de pconf,
avec une valeur de n égale à
100.
pconf jmoy
0,75 1,01
0,5 1,44
0,33 2,18
0,25 3,0
0,10 7,91
0,05 17,48
0,03 30,11
0,02 45,78
0,01 101,9

100.
pconf jmoy
0,75 1,01
0,5 1,44
0,33 2,18
0,25 3,0
0,10 7,91
0,05 17,48
0,03 30,11
0,02 45,78
0,01 101,9

100.
1 Le nombre de jours moyen
est presque inversement
proportionnelle à la valeur de
pconf. On a la formule
suivante : jmoy(p) ≈
0,68
p1,07
.
pconf jmoy
0,75 1,01
0,5 1,44
0,33 2,18
0,25 3,0
0,10 7,91
0,05 17,48
0,03 30,11
0,02 45,78
0,01 101,9

100.
1 Le nombre de jours moyen
est presque inversement
proportionnelle à la valeur de
pconf. On a la formule
suivante : jmoy(p) ≈
0,68
p1,07
.
2 Plus la valeur de pconf est
faible, plus le temps
d'exécution du programme
est élevée (croissance
linéaire).
pconf jmoy
0,75 1,01
0,5 1,44
0,33 2,18
0,25 3,0
0,10 7,91
0,05 17,48
0,03 30,11
0,02 45,78
0,01 101,9

Sain/infecté Évolution et calcul de probabilités
Sommaire
Population
2 Sain/infecté
Mise en place

Évolution de l'épidémie
On souhaite maintenant regarder l'évolution de l'épidémie jour après
jour.

jour.
Pour que les résultats soient représentatifs, on va prendre les valeurs
n=100 et pconf=0.01.

jour.
Pour que les résultats soient représentatifs, on va prendre les valeurs
n=100 et pconf=0.01.
On modie le programme pour obtenir les résultats voulus :
n=100
pcont =0.01
continit(n,pcont)
i=L.count (1)
s=n-i
j=0
while i!=n:
jour(n,pcont)
j=j+1
i=L.count (1)
s=n-i
print(j,i,s)

Graphique
On compile les résultats sur un graphique :

Graphique
On compile les résultats sur un graphique :
La courbe bleue (resp. rouge) représente le nombre de personnes infectées
(resp. saines) au l de la modélisation.

Remarque sur le graphique
La courbe bleue a la même forme qu'une fonction de répartition d'une
loi normale.

loi normale.
Cela veut dire qu'on a une accélération au beau milieu de la
modélisation et en début et à la n, l'évolution est faible voir quasi
nulle. On va essayer de montrer ce phénomène grâce à un calcul de
probabilités.

loi normale.
Cela veut dire qu'on a une accélération au beau milieu de la
modélisation et en début et à la n, l'évolution est faible voir quasi
nulle. On va essayer de montrer ce phénomène grâce à un calcul de
probabilités.
Pour mieux comprendre, on peut faire l'analogie suivante : On doit
descendre 10 pistes de ski sans tomber une seule fois. Au début, on
teste les pistes de ski, on peut tomber plusieurs fois. Puis avec de
l'entraînement, on nit facilement les pistes faciles et moyennes (qui
constituent une grande majorité des pistes) et enn avec du temps, on
termine les pistes les plus diciles (une par une).

Calcul de probabilités
On peut faire un arbre de probabilités.

On suppose qu'on est au kième jour de la modélisation, que la
population est constituée de n individus et que le virus a une
probabilité d'infection de p.

On note ik le nombre de personnes infectées et sk = n − ik le nombre
de personnes saines.

On note ik le nombre de personnes infectées et sk = n − ik le nombre
de personnes saines.
S1
S2
I2 S → I
I1
S2 S → I
I2
sk/n
(sk − 1)/(n − 1)
ik/(n − 1)
p
ik/n
sk/(n − 1)
p
(ik − 1)/(n − 1)

On a noté les événements suivants :

S1 : la première personne choisie est saine ;

I1 : la première personne choisie est infectée ;

S2 : la seconde personne choisie est saine ;

I2 : la seconde personne choisie est infectée .

S → I est l'événement : la personne saine est infectée pendant le
processus de rencontre . Elle se produit avec une probabilité p si les
événements S1 ∩ I2 ou S2 ∩ I1 sont réalisés.

S → I est l'événement : la personne saine est infectée pendant le
processus de rencontre . Elle se produit avec une probabilité p si les
événements S1 ∩ I2 ou S2 ∩ I1 sont réalisés.
On peut calculer P(S → I) grâce à la formule des probabilités totales :
P(S → I) = P(S1) × PS1(I2) × p + P(I2) × PI1(S2) × p
P(S → I) = p ×

sk
n
×
ik
n − 1
+
ik
n
×
sk
n − 1

=
2p × ik × sk
n(n − 1)
.

P(S → I) =
2p × ik × sk
n(n − 1)
.

P(S → I) =
2p × ik × sk
n(n − 1)
.
Les quantités p et n sont xes, ainsi la probabilité évolue avec les
quantités ik et sk.

P(S → I) =
2p × ik × sk
n(n − 1)
.
Elle est maximale si la valeur |ik − sk| est nulle (pour s'en convaincre,
vous pouvez étudier la fonction f : x 7→ x(100 − x) sur R).

P(S → I) =
2p × ik × sk
n(n − 1)
.
Elle est maximale si la valeur |ik − sk| est nulle (pour s'en convaincre,
vous pouvez étudier la fonction f : x 7→ x(100 − x) sur R).
Cela explique donc l'évolution des contaminés en forme de fonction de
répartition d'une loi binomiale.

États supplémentaires après l'infection
Sommaire
2 Sain/infecté

Introduction d'états supplémentaires
La récente actualité a démontré
qu'un virus avec une probabilité
d'infection de p n'est pas
présent éternellement dans
l'organisme d'un être humain.

Un être humain peut, après
être infecté, mourir du virus car
le virus a altéré des parties
vitaux de l'être...

Un être humain peut, après
être infecté, mourir du virus car
le virus a altéré des parties
vitaux de l'être...
ou alors guérir du virus, il ne
produit plus de charge viral car
le système immunitaire de la
personne infectée a bien fait
son travail.

Introduction d'eets supplémentaires
On supposera que le virus a une probabilité d'infection de p = 0,03 et
on va essayer de rendre la modélisation la plus réaliste possible. Cela
veut dire que si une personne est infectée le jour k, il ne meurt pas
forcément au jour k + 1.

Introduction d'eets supplémentaires
On supposera que le virus a une probabilité d'infection de p = 0,03 et
on va essayer de rendre la modélisation la plus réaliste possible. Cela
veut dire que si une personne est infectée le jour k, il ne meurt pas
forcément au jour k + 1.
On instaure donc ce tableau de probabilité de passage d'états.
S I1 I2 I3 I4 I5 I6 I7 I8 I9 I10 M G
S → 0 0,03 0,05 0,1 0,18 0,29 0 0 0 0 0 0 0
→ Ik+1 0 1 1 1 1 0,8 0,64 0,48 0,32 0,16 0 0 0
→ M 0 0 0 0 0 0,05 0,09 0,13 0,17 0,21 0,25 1 0
→ G 0 0 0 0 0 0,15 0,27 0,35 0,51 0,63 0,75 0 1

Explication du tableau de passage d'état
S I1 I2 I3 I4 I5 I6 I7 I8 I9 I10 M G
S → 0 0,03 0,05 0,1 0,18 0,29 0 0 0 0 0 0 0
→ Ik+1 0 1 1 1 1 0,8 0,64 0,48 0,32 0,16 0 0 0
→ M 0 0 0 0 0 0,05 0,09 0,13 0,17 0,21 0,25 1 0
→ G 0 0 0 0 0 0,15 0,27 0,35 0,51 0,63 0,75 0 1
On note :
S : personne saine;

S I1 I2 I3 I4 I5 I6 I7 I8 I9 I10 M G
S → 0 0,03 0,05 0,1 0,18 0,29 0 0 0 0 0 0 0
→ Ik+1 0 1 1 1 1 0,8 0,64 0,48 0,32 0,16 0 0 0
→ M 0 0 0 0 0 0,05 0,09 0,13 0,17 0,21 0,25 1 0
→ G 0 0 0 0 0 0,15 0,27 0,35 0,51 0,63 0,75 0 1
On note :
S : personne saine;
Ik : personne infectée, ke jour (1 6 k 6 10);

S I1 I2 I3 I4 I5 I6 I7 I8 I9 I10 M G
S → 0 0,03 0,05 0,1 0,18 0,29 0 0 0 0 0 0 0
→ Ik+1 0 1 1 1 1 0,8 0,64 0,48 0,32 0,16 0 0 0
→ M 0 0 0 0 0 0,05 0,09 0,13 0,17 0,21 0,25 1 0
→ G 0 0 0 0 0 0,15 0,27 0,35 0,51 0,63 0,75 0 1
On note :
S : personne saine;
M : personne morte du virus;

S I1 I2 I3 I4 I5 I6 I7 I8 I9 I10 M G
S → 0 0,03 0,05 0,1 0,18 0,29 0 0 0 0 0 0 0
→ Ik+1 0 1 1 1 1 0,8 0,64 0,48 0,32 0,16 0 0 0
→ M 0 0 0 0 0 0,05 0,09 0,13 0,17 0,21 0,25 1 0
→ G 0 0 0 0 0 0,15 0,27 0,35 0,51 0,63 0,75 0 1
On note :
S : personne saine;
M : personne morte du virus;
G : personne guérie du virus.

S I1 I2 I3 I4 I5 I6 I7 I8 I9 I10 M G
S → 0 0,03 0,05 0,1 0,18 0,29 0 0 0 0 0 0 0
→ Ik+1 0 1 1 1 1 0,8 0,64 0,48 0,32 0,16 0 0 0
→ M 0 0 0 0 0 0,05 0,09 0,13 0,17 0,21 0,25 1 0
→ G 0 0 0 0 0 0,15 0,27 0,35 0,51 0,63 0,75 0 1
La première ligne du tableau montre les probabilités d'infection pour une
personne saine rencontre une personne infectée, ke jour.
Une personne saine est infectée par des personnes dont le nombre de jours
d'infection est inférieure à 5 jours. Après 5 jours, on dit que le virus ne
contamine pas d'autres personnes.

S I1 I2 I3 I4 I5 I6 I7 I8 I9 I10 M G
S → 0 0,03 0,05 0,1 0,18 0,29 0 0 0 0 0 0 0
→ Ik+1 0 1 1 1 1 0,8 0,64 0,48 0,32 0,16 0 0 0
→ M 0 0 0 0 0 0,05 0,09 0,13 0,17 0,21 0,25 1 0
→ G 0 0 0 0 0 0,15 0,27 0,35 0,51 0,63 0,75 0 1
Le passage de l'état infecté à l'état mort ou guéri s'eectue selon les
fonctions de probabilités suivantes :
pi (x) = 1,6 − 0,16x pour x ∈ [5; 10] (probabilité de passage d'état
infecté à infecté)

S I1 I2 I3 I4 I5 I6 I7 I8 I9 I10 M G
S → 0 0,03 0,05 0,1 0,18 0,29 0 0 0 0 0 0 0
→ Ik+1 0 1 1 1 1 0,8 0,64 0,48 0,32 0,16 0 0 0
→ M 0 0 0 0 0 0,05 0,09 0,13 0,17 0,21 0,25 1 0
→ G 0 0 0 0 0 0,15 0,27 0,35 0,51 0,63 0,75 0 1
pm(x) = 0,04x − 0,15 pour x ∈ [5; 10] (probabilité de passage d'état
infecté à mort)

S I1 I2 I3 I4 I5 I6 I7 I8 I9 I10 M G
S → 0 0,03 0,05 0,1 0,18 0,29 0 0 0 0 0 0 0
→ Ik+1 0 1 1 1 1 0,8 0,64 0,48 0,32 0,16 0 0 0
→ M 0 0 0 0 0 0,05 0,09 0,13 0,17 0,21 0,25 1 0
→ G 0 0 0 0 0 0,15 0,27 0,35 0,51 0,63 0,75 0 1
pm(x) = 0,04x − 0,15 pour x ∈ [5; 10] (probabilité de passage d'état
infecté à mort)
pg (x) = 0,12x − 0,45 pour x ∈ [5; 10] (probabilité de passage d'état
infecté à guéri)

S I1 I2 I3 I4 I5 I6 I7 I8 I9 I10 M G
S → 0 0,03 0,05 0,1 0,18 0,29 0 0 0 0 0 0 0
→ Ik+1 0 1 1 1 1 0,8 0,64 0,48 0,32 0,16 0 0 0
→ M 0 0 0 0 0 0,05 0,09 0,13 0,17 0,21 0,25 1 0
→ G 0 0 0 0 0 0,15 0,27 0,35 0,51 0,63 0,75 0 1
On peut vérier que pg (x) = 3pm(x) (on a trois fois plus de chance de
guérir du virus que d'en mourir) et pi (x) + pg (x) + pm(x) = 1 (pour
tout x ∈ [5; 10]).

S I1 I2 I3 I4 I5 I6 I7 I8 I9 I10 M G
S → 0 0,03 0,05 0,1 0,18 0,29 0 0 0 0 0 0 0
→ Ik+1 0 1 1 1 1 0,8 0,64 0,48 0,32 0,16 0 0 0
→ M 0 0 0 0 0 0,05 0,09 0,13 0,17 0,21 0,25 1 0
→ G 0 0 0 0 0 0,15 0,27 0,35 0,51 0,63 0,75 0 1
On peut vérier que pg (x) = 3pm(x) (on a trois fois plus de chance de
guérir du virus que d'en mourir) et pi (x) + pg (x) + pm(x) = 1 (pour
tout x ∈ [5; 10]).
Les probabilités de contamination ont été déterminées par
interpolation polynomiale :





c(1) = 0,03
c(2) = 0,05
c(3) = 0,1
⇒ c(x) = 0,015x2
− 0,025x + 0,04.

Programmation
On va implémenter les états supplémentaires et leurs passages dans le
programme.

Programmation
programme.
Pour cela, on va transformer les états littérales (S, I1, ...) en états
numériques :

Programmation
programme.
numériques :
0 : personne saine;

Programmation
programme.
numériques :
0 : personne saine;
k : personne infectée, ke jour (1 6 k 6 10);

Programmation
programme.
numériques :
0 : personne saine;
11 : personne morte du virus;

Programmation
programme.
numériques :
0 : personne saine;
11 : personne morte du virus;
12 : personne guérie du virus.

Programmation
On programme tout d'abord une fonction pour le changement d'état
sain → infecté.
def passagesi(k):
return 0.015*k**2 -0.025*k+0.04
# dans le programme
if L[x]*L[y]==0 and 0L[x]+L[y]6:
if L[y]==0:
pconf=passagesi(L[x])
else:
pconf=passagesi(L[y])
conf=random ()
if conf = pconf:
if L[x]==0:
L[x]=13
else:
L[y]=13

Programmation
Remarque
On aecte à L[x] ou L[y] la valeur de 13 (nombre porte-malheur) pour ne
pas mélanger les infectés de la journée précédente qui doivent passer à
l'état infecté deuxième journée.
À la n de la journée, quand tout le monde aura changé d'état, on mettra
les éléments de la liste valant 13 à une valeur de 1.
# fin de modélisation
for k in range(len(L)):
if L[k]==13:
L[k]=1

Programmation
Le passage d'infecté jour k (1 6 k 6 9) au jour k + 1 peut être
modélisée par la boucle conditionnelle suivante à placer à la n d'un
jour de modélisation :
if 1=L[k] and L[k]=9:
L[k]=L[k]+1

Programmation
Le passage d'infecté jour k (1 6 k 6 9) au jour k + 1 peut être
modélisée par la boucle conditionnelle suivante à placer à la n d'un
jour de modélisation :
L[k]=L[k]+1
Remarque : dans ce cas, on n'a pas besoin de tenir compte des
probabilités de passage d'infection au jour suivant à cause du caractère
contraire de l'événement M ∪ G.

Programmation
Le passage d'infecté jour k (5 6 k 6 10) à mort peut être modélisée
par la fonction suivante
def passageim(k):
return 0.04*k -0.15
# dans le programme
pchg = passageim(k)
c = random ()
if c=pchg:
L[k]=11

Programmation
Le passage d'infecté jour k (5 6 k 6 10) à guéri peut être modélisée
def passageig(k):
return 0.12*k -0.45
# dans le programme
pchg = passageig(k)
c = random ()
if c=pchg:
L[k]=12

Programmation
Le passage d'infecté jour k (5 6 k 6 10) à guéri peut être modélisée
def passageig(k):
return 0.12*k -0.45
# dans le programme
pchg = passageig(k)
c = random ()
if c=pchg:
L[k]=12
Remarque : on peut mixer les deux codes pour simplier les choses (et
ne passer qu'une fois en vue les éléments de la liste).

Programmation
def passageim(k):
return 0.04*k -0.15
def passageig(k):
return 0.12*k -0.45
# dans le programme
pchg = passageig(k)
pchm = passageim(k)
c = random ()
if c=pchm:
L[k]=11
elif pchm =c and c=pchg+pchm:
L[k]=12

Programmation
On supprime les éléments guéris (12) et morts (11) de la liste en début de
modélisation.
# Suppression mort et guéri
L = [k for k in L if k != 11 and k!=12]

Test sur 100 personnes
On teste le programme pour une population de 100 personnes.
Voici un résultat en graphique :

Remarques sur les résultats
1 Le nombre de jours de modélisation est réduite de
2
3
(en moyenne).

2
3
(en moyenne).
2 On remarque comme précédemment une évolution de type loi
normale en ce qui concerne l'évolution des sains/infectés.

2
3
(en moyenne).
normale en ce qui concerne l'évolution des sains/infectés.
3 La proportion guéris/morts à la n de la modélisation est sensiblement
la même que la proportion des probabilités de guérison et de mortalité
attribués au dixième jour de contamination.

Eets de la vaccination
Sommaire
2 Sain/infecté

Introduction de la vaccination
Les recherches sur le virus ont
avancés et les laboratoires
pharmaceutiques peuvent
proposer à la population un
vaccin (qu'on appelera vaccin
14 ) qui est à 100 % ecace
contre la propagation du
virus...

Introduction de la vaccination
Les recherches sur le virus ont
avancés et les laboratoires
pharmaceutiques peuvent
proposer à la population un
vaccin (qu'on appelera vaccin
14 ) qui est à 100 % ecace
contre la propagation du
virus...
...si bien qu'une personne dont
on a inoculé le vaccin 14
(personne vaccinée) a une
probabilité nulle de se faire
contaminer par le virus. Il
pourra être donc éjecter de la
liste des contaminables.

Évolution de la vaccination
La propagation du vaccin 14 au sein de la population se fera petit à petit
sur le modèle d'évolution parabolique (comme l'évolution de la probabilité
d'infection selon le nombre de jours d'infection des personnes contaminés) :
au début, peu de personnes auront droit à une dose, la probabilité de
vaccination sera de 0,03;

elle atteint son pic au début du cinquième jour avec une probabilité de
vaccination de 0,28;

et cette probabilité retombe à 0,03 au dixième et dernier jour de la
campagne à cause de la réticence des anti-vaccins

La campagne vaccinale commence donc au tout début de la
modélisation et s'arrête à la n du dixième jour.

Elle s'eectue au début d'une journée de modélisation et il sut d'une
dose pour que la personne soit vaccinée.

Elle s'eectue au début d'une journée de modélisation et il sut d'une
dose pour que la personne soit vaccinée.
Une personne infectée ne reçoit pas de vaccin 14 car il développe déjà
des anticorps proposés par le vaccin.

Remarques de choix de modélisation
Choix de modélisation
Dans un premier temps, j'ai voulu choisir une évolution suivant la densité
de probabilité d'une loi normale de paramètre µ =
n
2
et σ =
n
10
mais les
valeurs de probabilités étaient trop petites par rapport aux probabilités de
contamination. Le choix ne serait donc pas pertinent car la vaccination
n'aurait aucun eet signicatif sur les résultats naux produits par le
programme.
Le choix nal se porte sur cette modélisation. La probabilité qu'une
personne soit vaccinée au jour k (0 6 k 6 10) est donnée par la fonction V
suivante dénie sur l'intervalle [0; 10] :
V (x) = −0,01x2
+ 0,1x + 0,03.

Programmation
On programme la vaccination en début de fonction jour. On enlève les
vaccinés de notre modélisation comme pour les morts et guéris.
def probavaccin(k):
return -0.01*k**2+0.1*k+0.03
def jour(n):
global L
global j
# Suppression mort et guéri
L = [k for k in L if k != 11 and k!=12 and k!=14]
# Vaccination
if j=10:
c = random ()
if c= probavaccin(j) and L[k]==0:
L[k]=14
# Rencontres
...

Programmation
et on compte en n de programme les vaccinés.
#Init. des variables
s=L.count (0)
i=L.count (1)
m=0
g=0
v=0
j=0
print(j,s,i,g,m)

Programmation
et on compte en n de programme les vaccinés.
#Init. des variables
s=L.count (0)
i=L.count (1)
m=0
g=0
v=0
j=0
print(j,s,i,g,m)
while i!=0:
jour(n)
j=j+1
s=L.count (0)
i=0
for k in range (1 ,10):
i=i+L.count(k)
m=m+L.count (11)
g=g+L.count (12)
v=v+L.count (14)
print(j,s,i,v,g,m)

Résultats avec vaccination
On lance le programme en prenant en compte la vaccination.
Voici un résultat :

1 Le nombre de jours de modélisation est réduite de moitié (en
moyenne).

moyenne).
normale en ce qui concerne l'évolution des vacinés.

moyenne).
3 Il y a en moyenne entre 50 % et 70 % de personnes vaccinées à la n
de la modélisation.

moyenne).
3 Il y a en moyenne entre 50 % et 70 % de personnes vaccinées à la n
de la modélisation.
4 Il y a toujours plus de guéris que de morts. Le nombre de morts chute
drastiquement (autour de 10 par modélisation) preuve que la
campagne vaccinale est ecace pour réduire la probabilité de mourir
d'une infection au virus.

JIM2021-1 - Modélisation discrète d'une épidémie

Recommandé

Recommandé

Contenu connexe

Plus de Clément Boulonne

Plus de Clément Boulonne (20)

JIM2021-1 - Modélisation discrète d'une épidémie