Darstellung von Konfidenzellipsen mit Matplotlib

Einführung

In diesem Lab wird gezeigt, wie man Konfidenzellipsen für einen zweidimensionalen Datensatz mit Python Matplotlib erstellt. Eine Konfidenzellipse ist eine grafische Darstellung der Kovarianz eines Datensatzes und zeigt die Unsicherheit des geschätzten Mittelwerts und der Standardabweichung. Die Ellipsen werden mithilfe des Pearson-Korrelationskoeffizienten gezeichnet.

Tipps für die virtuelle Maschine (VM)

Nachdem die VM gestartet wurde, klicken Sie in der oberen linken Ecke auf die Registerkarte Notebook, um auf Jupyter Notebook zuzugreifen und zu üben.

Manchmal müssen Sie möglicherweise einige Sekunden warten, bis Jupyter Notebook vollständig geladen ist. Aufgrund von Einschränkungen in Jupyter Notebook kann die Überprüfung von Operationen nicht automatisiert werden.

Wenn Sie während des Lernens Probleme haben, können Sie sich gerne an Labby wenden. Geben Sie uns nach der Sitzung Feedback, und wir werden das Problem umgehend für Sie lösen.

Importieren der erforderlichen Bibliotheken

Der erste Schritt besteht darin, die erforderlichen Bibliotheken zu importieren. Für dieses Lab benötigen wir numpy und matplotlib.pyplot.

import matplotlib.pyplot as plt
import numpy as np

Definition der Funktion confidence_ellipse

Als Nächstes definieren wir die Funktion confidence_ellipse, die die x- und y-Koordinaten des Datensatzes, das Achsenobjekt, in das die Ellipse gezeichnet werden soll, und die Anzahl der Standardabweichungen als Parameter erhält. Sie gibt ein Matplotlib-Patch-Objekt zurück, das die Ellipse repräsentiert.

def confidence_ellipse(x, y, ax, n_std=3.0, facecolor='none', **kwargs):
    """
    Erstellt ein Diagramm der Kovarianz-Konfidenzellipse von *x* und *y*.

    Parameter
    ----------
    x, y : array-ähnlich, Form (n, )
        Eingabedaten.

    ax : matplotlib.axes.Axes
        Das Achsenobjekt, in das die Ellipse gezeichnet werden soll.

    n_std : float
        Die Anzahl der Standardabweichungen, um die Radien der Ellipse zu bestimmen.

    **kwargs
        Weitergeleitet an `~matplotlib.patches.Ellipse`

    Rückgabewert
    -------
    matplotlib.patches.Ellipse
    """
    if x.size!= y.size:
        raise ValueError("x und y müssen die gleiche Größe haben")

    cov = np.cov(x, y)
    pearson = cov[0, 1]/np.sqrt(cov[0, 0] * cov[1, 1])
    ## Verwendung eines Spezialfalls, um die Eigenwerte dieses
    ## zweidimensionalen Datensatzes zu erhalten.
    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)

    ## Berechnung der Standardabweichung von x aus
    ## der Quadratwurzel der Varianz und Multiplikation
    ## mit der angegebenen Anzahl der Standardabweichungen.
    scale_x = np.sqrt(cov[0, 0]) * n_std
    mean_x = np.mean(x)

    ## Berechnung der Standardabweichung von 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)

Definition der Funktion get_correlated_dataset

Wir benötigen auch eine Funktion, um einen zweidimensionalen Datensatz mit einem angegebenen Mittelwert, Dimensionen und Korrelation zu generieren.

def get_correlated_dataset(n, dependency, mu, scale):
    """
    Erstellt einen zufälligen zweidimensionalen Datensatz mit dem angegebenen
    zweidimensionalen Mittelwert (mu) und Dimensionen (scale).
    Die Korrelation kann über den Parameter 'dependency', eine 2x2-Matrix, gesteuert werden.
    """
    latent = np.random.randn(n, 2)
    dependent = latent.dot(dependency)
    scaled = dependent * scale
    scaled_with_offset = scaled + mu
    ## Gibt x und y des neuen, korrelierten Datensatzes zurück
    return scaled_with_offset[:, 0], scaled_with_offset[:, 1]

Darstellung von positiver, negativer und schwacher Korrelation

Jetzt können wir diese Funktionen verwenden, um die Konfidenzellipsen von Datensätzen mit positiver, negativer und schwacher Korrelation zu plotten.

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

Darstellung unterschiedlicher Anzahlen von Standardabweichungen

Wir können auch die Konfidenzellipsen mit unterschiedlicher Anzahl von Standardabweichungen plotten.

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

Verwendung von Schlüsselwortargumenten (Keyword Arguments)

Schließlich können wir das Erscheinungsbild der Ellipsen mithilfe von Schlüsselwortargumenten anpassen.

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)
## Zeichne die Ellipse mit zorder=0, um
## ihre Transparenz (verursacht durch die Verwendung von alpha) zu demonstrieren.
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()

Zusammenfassung

In diesem Lab haben wir gelernt, wie man Konfidenzellipsen eines zweidimensionalen Datensatzes mit Python Matplotlib darstellt. Wir haben die Funktionen confidence_ellipse und get_correlated_dataset definiert und sie verwendet, um Ellipsen von Datensätzen mit unterschiedlicher Korrelation und Anzahl von Standardabweichungen zu plotten. Wir haben auch gezeigt, wie man das Erscheinungsbild der Ellipsen mithilfe von Schlüsselwortargumenten (Keyword Arguments) anpasst.