Introduction
Ce laboratoire démontrera comment tracer des ellipses de confiance pour un ensemble de données bidimensionnelles à l'aide de Python Matplotlib. Une ellipse de confiance est une représentation graphique de la covariance d'un ensemble de données, montrant l'incertitude de la moyenne estimée et de l'écart-type. Les ellipses sont tracées à l'aide du coefficient de corrélation de Pearson.
Conseils pour la machine virtuelle (VM)
Une fois le démarrage de la machine virtuelle terminé, cliquez dans le coin supérieur gauche pour basculer vers l'onglet Notebook afin d'accéder à Jupyter Notebook pour pratiquer.
Parfois, vous devrez peut-être attendre quelques secondes que Jupyter Notebook ait terminé de charger. La validation des opérations ne peut pas être automatisée en raison des limitations de Jupyter Notebook.
Si vous rencontrez des problèmes pendant votre apprentissage, n'hésitez pas à demander de l'aide à Labby. Fournissez vos commentaires après la session, et nous résoudrons rapidement le problème pour vous.
Importation des bibliothèques requises
La première étape consiste à importer les bibliothèques nécessaires. Pour ce laboratoire, nous aurons besoin de numpy et de matplotlib.pyplot.
import matplotlib.pyplot as plt
import numpy as np
Définition de la fonction confidence_ellipse
Ensuite, nous définissons la fonction confidence_ellipse qui prendra en entrée les coordonnées x et y de l'ensemble de données, l'objet d'axes (axes object) dans lequel tracer l'ellipse et le nombre d'écarts-types. Elle renvoie un objet patch de Matplotlib représentant l'ellipse.
def confidence_ellipse(x, y, ax, n_std=3.0, facecolor='none', **kwargs):
"""
Crée un graphique de l'ellipse de confiance de covariance de *x* et *y*.
Paramètres
----------
x, y : semblable à un tableau, forme (n, )
Données d'entrée.
ax : matplotlib.axes.Axes
L'objet d'axes dans lequel tracer l'ellipse.
n_std : flottant
Le nombre d'écarts-types pour déterminer les rayons de l'ellipse.
**kwargs
Transmis à `~matplotlib.patches.Ellipse`
Retours
-------
matplotlib.patches.Ellipse
"""
if x.size!= y.size:
raise ValueError("x et y doivent avoir la même taille")
cov = np.cov(x, y)
pearson = cov[0, 1]/np.sqrt(cov[0, 0] * cov[1, 1])
## Utilisation d'un cas particulier pour obtenir les valeurs propres de cet
## ensemble de données bidimensionnel.
ell_radius_x = np.sqrt(1 + pearson)
ell_radius_y = np.sqrt(1 - pearson)
ellipse = Ellipse((0, 0), width=ell_radius_x * 2, height=ell_radius_y * 2,
facecolor=facecolor, **kwargs)
## Calcul de l'écart-type de x à partir
## de la racine carrée de la variance et multiplication
## par le nombre donné d'écarts-types.
scale_x = np.sqrt(cov[0, 0]) * n_std
mean_x = np.mean(x)
## calcul de l'écart-type de y...
scale_y = np.sqrt(cov[1, 1]) * n_std
mean_y = np.mean(y)
transf = transforms.Affine2D() \
.rotate_deg(45) \
.scale(scale_x, scale_y) \
.translate(mean_x, mean_y)
ellipse.set_transform(transf + ax.transData)
return ax.add_patch(ellipse)
Définition de la fonction get_correlated_dataset
Nous avons également besoin d'une fonction pour générer un ensemble de données bidimensionnelles avec une moyenne, des dimensions et une corrélation spécifiées.
def get_correlated_dataset(n, dependency, mu, scale):
"""
Crée un ensemble de données bidimensionnelles aléatoires avec la moyenne bidimensionnelle (mu) et les dimensions (scale) spécifiées.
La corrélation peut être contrôlée par le paramètre 'dependency', une matrice 2x2.
"""
latent = np.random.randn(n, 2)
dependent = latent.dot(dependency)
scaled = dependent * scale
scaled_with_offset = scaled + mu
## retourne x et y du nouvel ensemble de données corrélé
return scaled_with_offset[:, 0], scaled_with_offset[:, 1]
Tracé des corrélations positives, négatives et faibles
Maintenant, nous pouvons utiliser ces fonctions pour tracer les ellipses de confiance d'ensembles de données avec des corrélations positives, négatives et faibles.
np.random.seed(0)
PARAMETERS = {
'Positive correlation': [[0.85, 0.35],
[0.15, -0.65]],
'Negative correlation': [[0.9, -0.4],
[0.1, -0.6]],
'Weak correlation': [[1, 0],
[0, 1]],
}
mu = 2, 4
scale = 3, 5
fig, axs = plt.subplots(1, 3, figsize=(9, 3))
for ax, (title, dependency) in zip(axs, PARAMETERS.items()):
x, y = get_correlated_dataset(800, dependency, mu, scale)
ax.scatter(x, y, s=0.5)
ax.axvline(c='grey', lw=1)
ax.axhline(c='grey', lw=1)
confidence_ellipse(x, y, ax, edgecolor='red')
ax.scatter(mu[0], mu[1], c='red', s=3)
ax.set_title(title)
plt.show()
Tracé de différentes valeurs d'écart-type
Nous pouvons également tracer les ellipses de confiance avec différents nombres d'écarts-types.
fig, ax_nstd = plt.subplots(figsize=(6, 6))
dependency_nstd = [[0.8, 0.75],
[-0.2, 0.35]]
mu = 0, 0
scale = 8, 5
ax_nstd.axvline(c='grey', lw=1)
ax_nstd.axhline(c='grey', lw=1)
x, y = get_correlated_dataset(500, dependency_nstd, mu, scale)
ax_nstd.scatter(x, y, s=0.5)
confidence_ellipse(x, y, ax_nstd, n_std=1,
label=r'$1\sigma$', edgecolor='firebrick')
confidence_ellipse(x, y, ax_nstd, n_std=2,
label=r'$2\sigma$', edgecolor='fuchsia', linestyle='--')
confidence_ellipse(x, y, ax_nstd, n_std=3,
label=r'$3\sigma$', edgecolor='blue', linestyle=':')
ax_nstd.scatter(mu[0], mu[1], c='red', s=3)
ax_nstd.set_title('Different standard deviations')
ax_nstd.legend()
plt.show()
Utilisation d'arguments clé-valeur
Enfin, nous pouvons personnaliser l'apparence des ellipses en utilisant des arguments clé-valeur (keyword arguments).
fig, ax_kwargs = plt.subplots(figsize=(6, 6))
dependency_kwargs = [[-0.8, 0.5],
[-0.2, 0.5]]
mu = 2, -3
scale = 6, 5
ax_kwargs.axvline(c='grey', lw=1)
ax_kwargs.axhline(c='grey', lw=1)
x, y = get_correlated_dataset(500, dependency_kwargs, mu, scale)
## Trace l'ellipse avec zorder=0 afin de démontrer
## sa transparence (causée par l'utilisation de alpha).
confidence_ellipse(x, y, ax_kwargs,
alpha=0.5, facecolor='pink', edgecolor='purple', zorder=0)
ax_kwargs.scatter(x, y, s=0.5)
ax_kwargs.scatter(mu[0], mu[1], c='red', s=3)
ax_kwargs.set_title('Using keyword arguments')
fig.subplots_adjust(hspace=0.25)
plt.show()
Résumé
Dans ce laboratoire (lab), nous avons appris à tracer des ellipses de confiance pour un ensemble de données bidimensionnelles en utilisant Python et Matplotlib. Nous avons défini les fonctions confidence_ellipse et get_correlated_dataset, et les avons utilisées pour tracer des ellipses pour des ensembles de données avec différentes corrélations et nombres d'écarts-types. Nous avons également montré comment personnaliser l'apparence des ellipses en utilisant des arguments clé-valeur (keyword arguments).