Einfache eindimensionale Kernel-Dichteschätzung

Einführung

Die Kernel-Dichteschätzung ist eine statistische Technik, die zur Schätzung der Wahrscheinlichkeitsdichtefunktion einer Zufallsvariablen verwendet wird. In diesem Lab verwenden wir die Python-Bibliothek scikit-learn, um die Grundprinzipien der Kernel-Dichteschätzung in einer Dimension zu demonstrieren.

Tipps für die VM

Nachdem der VM-Start abgeschlossen ist, klicken Sie in der oberen linken Ecke, um zur Registerkarte Notebook zu wechseln und Jupyter Notebook für die Übung zu öffnen.

Manchmal müssen Sie einige Sekunden warten, bis Jupyter Notebook vollständig geladen ist. Die Validierung von Vorgängen kann aufgrund der Einschränkungen von Jupyter Notebook nicht automatisiert werden.

Wenn Sie bei der Lernphase Probleme haben, können Sie Labby gerne fragen. Geben Sie nach der Sitzung Feedback, und wir werden das Problem für Sie prompt beheben.

Skills Graph

Darstellung von Histogrammen und Kernen

Wir zeichnen zunächst Histogramme und Kerne, um den Unterschied zwischen den beiden zu demonstrieren. Wir werden eine Gaußsche Kernel-Dichteschätzung verwenden, um den Unterschied zwischen den beiden zu zeigen. Wir werden auch andere Kerne vergleichen, die in scikit-learn verfügbar sind.

## Import notwendige Bibliotheken
import numpy as np
import matplotlib.pyplot as plt
from scipy.stats import norm
from sklearn.neighbors import KernelDensity

## Generiere Daten
np.random.seed(1)
N = 20
X = np.concatenate(
    (np.random.normal(0, 1, int(0.3 * N)), np.random.normal(5, 1, int(0.7 * N)))
)[:, np.newaxis]
X_plot = np.linspace(-5, 10, 1000)[:, np.newaxis]
bins = np.linspace(-5, 10, 10)

## Erstelle Figur und Achsen
fig, ax = plt.subplots(2, 2, sharex=True, sharey=True)
fig.subplots_adjust(hspace=0.05, wspace=0.05)

## Zeichne Histogramm 1
ax[0, 0].hist(X[:, 0], bins=bins, fc="#AAAAFF", density=True)
ax[0, 0].text(-3.5, 0.31, "Histogramm")

## Zeichne Histogramm 2
ax[0, 1].hist(X[:, 0], bins=bins + 0.75, fc="#AAAAFF", density=True)
ax[0, 1].text(-3.5, 0.31, "Histogramm, Bins verschoben")

## Zeichne Tophat-KDE
kde = KernelDensity(kernel="tophat", bandwidth=0.75).fit(X)
log_dens = kde.score_samples(X_plot)
ax[1, 0].fill(X_plot[:, 0], np.exp(log_dens), fc="#AAAAFF")
ax[1, 0].text(-3.5, 0.31, "Tophat-Kernel-Dichte")

## Zeichne Gaußsche KDE
kde = KernelDensity(kernel="gaussian", bandwidth=0.75).fit(X)
log_dens = kde.score_samples(X_plot)
ax[1, 1].fill(X_plot[:, 0], np.exp(log_dens), fc="#AAAAFF")
ax[1, 1].text(-3.5, 0.31, "Gaußsche Kernel-Dichte")

## Zeichne Datenpunkte
for axi in ax.ravel():
    axi.plot(X[:, 0], np.full(X.shape[0], -0.01), "+k")
    axi.set_xlim(-4, 9)
    axi.set_ylim(-0.02, 0.34)

## Setze y-Achsenbeschriftung für die linke Spalte
for axi in ax[:, 0]:
    axi.set_ylabel("Normalisierte Dichte")

## Setze x-Achsenbeschriftung für die untere Zeile
for axi in ax[1, :]:
    axi.set_xlabel("x")

## Zeige das Diagramm an
plt.show()

Darstellung der verfügbaren Kerne

Wir werden alle verfügbaren Kerne darstellen, um ihre Formen zu zeigen.

## Generiere Daten
X_plot = np.linspace(-6, 6, 1000)[:, None]
X_src = np.zeros((1, 1))

## Erstelle Figur und Achsen
fig, ax = plt.subplots(2, 3, sharex=True, sharey=True)
fig.subplots_adjust(left=0.05, right=0.95, hspace=0.05, wspace=0.05)

## Formatierungsfunktion für die x-Achsenbeschriftungen
def format_func(x, loc):
    if x == 0:
        return "0"
    elif x == 1:
        return "h"
    elif x == -1:
        return "-h"
    else:
        return "%ih" % x

## Zeichne die verfügbaren Kerne
for i, kernel in enumerate(
    ["gaussian", "tophat", "epanechnikov", "exponential", "linear", "cosine"]
):
    axi = ax.ravel()[i]
    log_dens = KernelDensity(kernel=kernel).fit(X_src).score_samples(X_plot)
    axi.fill(X_plot[:, 0], np.exp(log_dens), "-k", fc="#AAAAFF")
    axi.text(-2.6, 0.95, kernel)

    axi.xaxis.set_major_formatter(plt.FuncFormatter(format_func))
    axi.xaxis.set_major_locator(plt.MultipleLocator(1))
    axi.yaxis.set_major_locator(plt.NullLocator())

    axi.set_ylim(0, 1.05)
    axi.set_xlim(-2.9, 2.9)

## Setze Titel für die zweite Zeile
ax[0, 1].set_title("Verfügbare Kerne")

## Zeige das Diagramm an
plt.show()

Darstellung eines eindimensionalen Dichtbeispiels

Wir werden ein eindimensionales Dichtbeispiel mit 100 Stichproben in einer Dimension darstellen. Wir werden drei verschiedene Kernel-Dichteschätzungen vergleichen: Tophat, Gauß und Epanechnikov.

## Generiere Daten
N = 100
np.random.seed(1)
X = np.concatenate(
    (np.random.normal(0, 1, int(0.3 * N)), np.random.normal(5, 1, int(0.7 * N)))
)[:, np.newaxis]

X_plot = np.linspace(-5, 10, 1000)[:, np.newaxis]

true_dens = 0.3 * norm(0, 1).pdf(X_plot[:, 0]) + 0.7 * norm(5, 1).pdf(X_plot[:, 0])

## Erstelle Figur und Achsen
fig, ax = plt.subplots()

## Zeichne die Eingabeverteilung
ax.fill(X_plot[:, 0], true_dens, fc="black", alpha=0.2, label="Eingabeverteilung")

## Setze Farben und Kerne
colors = ["navy", "cornflowerblue", "darkorange"]
kernels = ["gaussian", "tophat", "epanechnikov"]
lw = 2

## Zeichne die Kernel-Dichteschätzungen
for color, kernel in zip(colors, kernels):
    kde = KernelDensity(kernel=kernel, bandwidth=0.5).fit(X)
    log_dens = kde.score_samples(X_plot)
    ax.plot(
        X_plot[:, 0],
        np.exp(log_dens),
        color=color,
        lw=lw,
        linestyle="-",
        label="kernel = '{0}'".format(kernel),
    )

ax.text(6, 0.38, "N={0} Punkte".format(N))

## Setze Legende und zeichne die Datenpunkte
ax.legend(loc="upper left")
ax.plot(X[:, 0], -0.005 - 0.01 * np.random.random(X.shape[0]), "+k")

## Setze die x- und y-Begrenzungen
ax.set_xlim(-4, 9)
ax.set_ylim(-0.02, 0.4)

## Zeige das Diagramm an
plt.show()

Zusammenfassung

In diesem Lab haben wir gelernt, wie man die Python-Bibliothek scikit-learn verwendet, um die Grundprinzipien der Kernel-Dichteschätzung in einer Dimension zu demonstrieren. Wir haben Histogramme und Kerne, verfügbare Kerne und ein eindimensionales Dichtbeispiel geplottet. Wir haben auch verschiedene Kernel-Dichteschätzungen verglichen.