Simulation de la méthode de Capture - Marquage - Recapture

Module utile pour les représentations graphiques et fonctions utiles pour la génération de nombres aléatoires et le calcul d'une racine carrée :

In [1]:
import matplotlib.pyplot as plt
from random import random, randint
from math import sqrt

Aspect mathématique

Loi de Bernoulli

  1. Ecrire une fonction bernoulli(p) simulant une variable aléatoire suivant une loi de Bernoulli de paramètre p, c'est-à-dire une fonction qui renvoie 1 avec une probabilité p et qui renvoie 0 avec une probabilité 1-p.
In [2]:
def bernoulli(p):
    alea = random()
    if alea < p:
        return 1
    else :
        return 0
In [3]:
bernoulli(0.4)
Out[3]:
0

Génération d'un échantillon

  1. Ecrire une fonction freq_rep_bernoulli(n, p) qui renvoie la fréquence d'apparition de la valeur 1 dans un échantillon de taille n de variables aléatoires suivant une loi de Bernoulli de paramètre p.
In [4]:
def freq_rep_bernoulli(n, p):
    f = 0
    for i in range(n):
        f = f + bernoulli(p)
    return f/n
In [5]:
freq_rep_bernoulli(1000, 0.3)
Out[5]:
0.307

La fréquence $f$ calculée par la fonction freq_rep_bernoulli(n, p) est un estimation de la proportion p à partir d'un échantillon de taille $n$.
Un intervalle de confiance pour cette proportion, au niveau de 95%, est : $$\left[ f-\frac{1}{\sqrt{n}};f+\frac{1}{\sqrt{n}}\right]$$

  1. Ecrire une fonction freq_rep_bernoulli_confiance(n, p) identique à la fonction précédente mais qui renvoie en plus les bornes d'un intervalle de confiance au niveau de 95%.
In [6]:
def freq_rep_bernoulli_confiance(n, p):
    f = 0
    for i in range(n):
        f = f + bernoulli(p)
    f = f/n
    return f, f-1/sqrt(n), f+1/sqrt(n)
In [7]:
freq_rep_bernoulli_confiance(1000, 0.3)
Out[7]:
(0.308, 0.2763772233983162, 0.3396227766016838)

Génération d'échantillons

  1. Ecrire une fonction liste_freq_rep_bernoulli(e, n, p) qui renvoie une liste de e éléments, chaque élément contenant la fréquence d'appartition de la valeur 1 dans un échantillon de taille n de variables aléatoires suivant une loi de Bernoulli de paramètre p.
In [8]:
def liste_freq_rep_bernoulli(e, n, p):
    lf = []
    for i in range(e):
        lf.append(freq_rep_bernoulli(n, p))
    return lf
In [9]:
liste_freq_rep_bernoulli(5, 1000, 0.4)
Out[9]:
[0.394, 0.418, 0.418, 0.405, 0.376]

Représentation graphique d'un ensemble d'échantillons

On veut représenter graphiquement les fréquences obtenues pour plusieurs échantillons.

In [10]:
# paramètre p d'une loi de Bernoulli
p_bernoulli = 0.4
# taille n d'un échantillon
taille_echantillon = 1000
# nombre e d'échantillons à réaliser
nb_echantillon = 100
liste_freq = liste_freq_rep_bernoulli(nb_echantillon, taille_echantillon, p_bernoulli)

Dans la représentation graphique ci-dessous, on trace, pour chaque fréquence de chaque échantillon, l'intervalle de confiance correspondant.

Le paramètre $p$ de la variable de Bernoulli est également représenté, ce qui permet d'observer les cas, rares, où $p$ n'appartient pas à l'intervalle de confiance centrée sur la fréquence simulée.

In [11]:
x = list(range(nb_echantillon))
ymin, ymax = min(liste_freq), max(liste_freq)

plt.figure(figsize = (18, 5))
plt.ylim(ymin-0.05, ymax+0.05)
plt.xlabel("échantillons de taille {}".format(taille_echantillon))
plt.ylabel("fréq. obtenue par l'échantillon simulé")
plt.scatter(x, liste_freq, s=14)
plt.errorbar(x, liste_freq, yerr = 1/sqrt(taille_echantillon), fmt = 'none', capsize = 4, errorevery = 1, ecolor = 'red')
plt.plot(x, [p_bernoulli]*nb_echantillon, 'g--')
plt.show()
# plt.savefig('repr_ech_freq_confiance.png', dpi = 600)

Mise en oeuvre pour la méthode de Capture-Marquage-Recapture

Supposons une population dont l'effectif $N$ est inconnu, dans laquelle on a capturé et marqué 800 individus.
Le rapport $p=\frac{800}{N}$ est la proportion d'individus marqués dans cette population.

Pour réaliser une simulation, choisissons au hasard, à l'aide de Python, l'effectif de la population totale $N$ entre 4000 et 6000 individus, stocké ci-dessous dans la variable effectif_total.
On évite d'afficher $N$ afin de simuler le fait de l'ignorer.

In [12]:
effectif_total = randint(4000, 6000)
marques = 800
proportion = marques/effectif_total
  1. A quelle étape de la méthode de Capture-Marquage-Recapture correspond la fonction freq_rep_bernoulli(n,p) ?

La fonction freq_rep_bernoulli(n,p) permet de simuler la capture de n individus dans une population dans laquelle une proportion p d'individus sont marqués.

  1. Ecrire une fonction eval_pop_totale(n, m, p) qui renvoie une estimation de l'effectif de la population totale par la méthode de Capture, Marquage et Recapture. n est la taille de l'échantillon prélevé dans une population ayant mindividus préalablement marqués correspondant à une proportion p d'individus marqués.
In [13]:
def eval_pop_totale(n, m, p):
    f = freq_rep_bernoulli(n, p)
    return int(m/f)
In [14]:
eval_pop_totale(200, marques, proportion)
Out[14]:
4571
  1. Compléter la fonction eval_pop_totale(n, m, p) de sorte qu'elle renvoie également les bornes d'un encadrement de l'effectif de la population totale obtenus à partir de l'intervalle de confiance à 95% de la fréquence calculée.
In [15]:
def eval_pop_totale(n, m, p):
    f = freq_rep_bernoulli(n, p)
    return int(m/(f+1/sqrt(n))), int(m/f), int(m/(f-1/sqrt(n))+1)
In [16]:
eval_pop_totale(200, marques, proportion)
Out[16]:
(3544, 5161, 9492)