Traccia un'ellisse di confidenza di un set di dati bidimensionale

Questo esempio mostra come tracciare un'ellisse di confidenza di un set di dati bidimensionale, utilizzando il relativo coefficiente di correlazione di Pearson.

L'approccio utilizzato per ottenere la geometria corretta è spiegato e dimostrato qui:

https://carstenschelp.github.io/2018/09/14/Plot_Confidence_Ellipse_001.html

Il metodo evita l'uso di un algoritmo iterativo di decomposizione di eigen e si avvale del fatto che una matrice di covarianza normalizzata (composta da coefficienti e coefficienti di correlazione Pearson) è particolarmente facile da gestire.

import numpy as np
import matplotlib.pyplot as plt
from matplotlib.patches import Ellipse
import matplotlib.transforms as transforms

La stessa funzione di tracciamento

Questa funzione traccia l'ellisse di confidenza della covarianza delle variabili di tipo matrice x e y fornite. L'ellisse viene tracciata nel dato asse-oggetto ax.

I raggi dell'ellisse possono essere controllati da n_std che è il numero di deviazioni standard. Il valore predefinito è 3 che fa sì che l'ellisse racchiuda il 98,9% dei punti se i dati sono distribuiti normalmente come in questi esempi (3 deviazioni standard in 1-D contengono il 99,7% dei dati, che è il 98,9% dei dati in 2-D D).

def confidence_ellipse(x, y, ax, n_std=3.0, facecolor='none', **kwargs):
    """
    Create a plot of the covariance confidence ellipse of *x* and *y*.

    Parameters
    ----------
    x, y : array-like, shape (n, )
        Input data.

    ax : matplotlib.axes.Axes
        The axes object to draw the ellipse into.

    n_std : float
        The number of standard deviations to determine the ellipse's radiuses.

    **kwargs
        Forwarded to `~matplotlib.patches.Ellipse`

    Returns
    -------
    matplotlib.patches.Ellipse
    """
    if x.size != y.size:
        raise ValueError("x and y must be the same size")

    cov = np.cov(x, y)
    pearson = cov[0, 1]/np.sqrt(cov[0, 0] * cov[1, 1])
    # Using a special case to obtain the eigenvalues of this
    # two-dimensional dataset.
    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)

    # Calculating the standard deviation of x from
    # the squareroot of the variance and multiplying
    # with the given number of standard deviations.
    scale_x = np.sqrt(cov[0, 0]) * n_std
    mean_x = np.mean(x)

    # calculating the standard deviation of 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)

Una funzione di supporto per creare un set di dati correlato

Crea un set di dati bidimensionale casuale con la media bidimensionale (mu) e le dimensioni (scala) specificate. La correlazione può essere controllata dal parametro 'dipendenza', una matrice 2x2.

def get_correlated_dataset(n, dependency, mu, scale):
    latent = np.random.randn(n, 2)
    dependent = latent.dot(dependency)
    scaled = dependent * scale
    scaled_with_offset = scaled + mu
    # return x and y of the new, correlated dataset
    return scaled_with_offset[:, 0], scaled_with_offset[:, 1]

Correlazione positiva, negativa e debole

Si noti che la forma per la correlazione debole (a destra) è un'ellisse, non un cerchio perché xey sono scalati in modo diverso. Tuttavia, il fatto che x e y non siano correlati è dimostrato dall'allineamento degli assi dell'ellisse con l'asse x e y del sistema di coordinate.

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()

Numero diverso di deviazioni standard

Un grafico con n_std = 3 (blu), 2 (viola) e 1 (rosso)

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()

Usando gli argomenti della parola chiave

Utilizzare gli argomenti della parola chiave specificati per matplotlib.patches.Patchper rendere l'ellisse in modi diversi.

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)
# Plot the ellipse with zorder=0 in order to demonstrate
# its transparency (caused by the use of 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()

Riferimenti

L'uso delle seguenti funzioni, metodi, classi e moduli è mostrato in questo esempio:

• matplotlib.transforms.Affine2D

• matplotlib.patches.Ellipse