0Pricing
Pandas & NumPy Academy · Lektion

Interpolation und fortgeschrittene Imputation

Verwenden Sie interpolate() zum gleichmäßigen zeitbasierten Auffüllen und lernen Sie, wann eine Imputation mit Mittelwert oder Median sinnvoll ist.

Interpolation und fortgeschrittene Imputation ist eine kostenlose Pandas & NumPy Academy-Lektion auf CoddyKit. Dies ist Lektion 4 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Pandas & NumPy Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Pandas & NumPy Academy-Kurs umfasst insgesamt 4 Lektionen.

Wann Interpolation fillna() überlegen ist

Vorwärts- und Rückwärtsauffüllen übertragen den nächstgelegenen bekannten Wert, ohne den Trend der Daten zu berücksichtigen. Bei der Interpolation werden fehlende Werte geschätzt, indem ein gleichmäßiger Übergang zwischen bekannten Werten angenommen wird – wenn die Temperatur beispielsweise am Montag 20 °C und am Freitag 30 °C betrug, schätzt die Interpolation für Mittwoch 25 °C. Dadurch entstehen realistischere Imputationen für sich gleichmäßig verändernde Signale wie Sensordaten, Preise oder Bevölkerungszahlen.

import pandas as pd
import numpy as np

df = pd.DataFrame({
    'day': [1, 2, 3, 4, 5],
    'temp': [20.0, np.nan, np.nan, np.nan, 30.0]
})

# Linear interpolation fills gaps smoothly
df['temp_interp'] = df['temp'].interpolate(method='linear')
print(df)
#    day  temp  temp_interp
# 0    1  20.0         20.0
# 1    2   NaN         22.5
# 2    3   NaN         25.0
# 3    4   NaN         27.5
# 4    5  30.0         30.0

interpolate()-Methoden

Pandas interpolate() unterstützt mehrere Methoden. Die häufigsten sind 'linear' (gleichmäßig zwischen bekannten Werten verteilt), 'time' (berücksichtigt ungleichmäßige Zeitabstände, wenn ein DatetimeIndex gesetzt ist), 'polynomial' (passt eine Polynomenkurve an und erfordert ein order-Argument) und 'spline' (glattes stückweise definiertes Polynom). Linear ist die sicherste Standardeinstellung; Methoden höherer Ordnung können kleine Lücken überanpassen.

import pandas as pd
import numpy as np

s = pd.Series([0, np.nan, np.nan, 8.0])

print('linear:', s.interpolate('linear').tolist())
# [0.0, 2.6666..., 5.3333..., 8.0]

print('polynomial(2):', s.interpolate('polynomial', order=2).tolist())
# [0.0, 2.222..., 5.111..., 8.0]

Zeitinterpolation mit DatetimeIndex

Wenn Ihre Series einen DatetimeIndex mit ungleichmäßigen Zeitabständen besitzt (z. B. nur Werktage, fehlende Wochenenden), interpoliert method='time' proportional zur tatsächlich verstrichenen Zeit und nicht nur anhand der Position. Das ist genauer als die lineare Interpolation, bei der jede Zeile unabhängig von der Kalenderlücke als gleichmäßig verteilt behandelt wird.

import pandas as pd
import numpy as np

# Unequal gaps: Jan 1, Jan 3, Jan 10
idx = pd.to_datetime(['2024-01-01', '2024-01-03', '2024-01-10'])
s = pd.Series([100.0, np.nan, 170.0], index=idx)

# linear treats gaps as equal (position-based)
print(s.interpolate('linear').tolist())  # [100.0, 135.0, 170.0]

# time accounts for actual day count
# Jan 1 to Jan 3 = 2 days, Jan 1 to Jan 10 = 9 days
# fraction: 2/9 of the way from 100 to 170
print(s.interpolate('time').tolist())   # [100.0, 115.55..., 170.0]

Ausdehnung der Interpolation begrenzen

Wie ffill() akzeptiert auch interpolate() einen Parameter limit, der festlegt, wie viele aufeinanderfolgende NaN-Positionen aufgefüllt werden. Verbleibende NaN-Werte jenseits dieses Limits bleiben fehlend. So wird verhindert, dass über sehr lange Lücken hinweg interpoliert wird, in denen der tatsächliche Wert beliebig sein könnte – lange Lücken sollten zur manuellen Prüfung markiert werden.

import pandas as pd
import numpy as np

s = pd.Series([1.0, np.nan, np.nan, np.nan, np.nan, 10.0])

# Only fill the first 2 NaN positions
filled = s.interpolate('linear', limit=2)
print(filled.tolist())
# [1.0, 2.8, 4.6, NaN, NaN, 10.0]

Imputation mit Mittelwert oder Median auswählen

Imputation mit Mittelwert oder Median ist einfach, bringt aber wichtige Kompromisse mit sich. Der Mittelwert reagiert empfindlich auf Ausreißer – einige sehr große Werte ziehen ihn nach oben und machen ihn für eine rechtsschiefe Verteilung wie Einkommen oder Immobilienpreise zu einem schlechten Auffüllwert. Der Median ist robust gegenüber Ausreißern und die bessere Wahl für schiefe Spalten. Verwenden Sie den Mittelwert nur, wenn Ihre Daten ungefähr symmetrisch sind und keine extremen Ausreißer enthalten.

import pandas as pd
import numpy as np

# Skewed income data with an outlier
income = pd.Series([30000, 35000, 32000, 1_000_000, np.nan])

print('Mean:  ', income.mean())    # ~274000 — pulled by outlier
print('Median:', income.median())  # ~33500 — robust choice

# Prefer median for skewed data
filled = income.fillna(income.median())
print(filled.tolist())
# [30000, 35000, 32000, 1000000, 33500.0]

Konzept der KNN-Imputation

Bei der K-Nearest-Neighbour-(KNN-)Imputation wird ein fehlender Wert durch den Mittelwert (oder gewichteten Mittelwert) der k ähnlichsten Zeilen ersetzt. Die Ähnlichkeit wird anhand der Distanz über nicht fehlende Merkmale gemessen. Dies ist eine multivariate Strategie: Sie verwendet Informationen aus anderen Spalten, um den Ersatzwert zu bestimmen. Bei korrelierten Merkmalen ist sie dadurch genauer als eine einspaltige Mittelwert-Imputation.

Scikit-learn's KNNImputer lässt sich direkt mit NumPy-Arrays und Pandas-DataFrames verwenden.

import pandas as pd
import numpy as np
from sklearn.impute import KNNImputer

df = pd.DataFrame({
    'age': [25, 35, np.nan, 45],
    'income': [50000, 70000, 60000, np.nan]
})

imputer = KNNImputer(n_neighbors=2)
df_imputed = pd.DataFrame(
    imputer.fit_transform(df),
    columns=df.columns
)
print(df_imputed.round(1))
#     age   income
# 0  25.0  50000.0
# 1  35.0  70000.0
# 2  30.0  60000.0   <- filled from neighbours
# 3  45.0  65000.0   <- filled from neighbours

Multiple Imputation mit IterativeImputer

Multiple Imputation gilt in der statistischen Forschung als Goldstandard für den Umgang mit fehlenden Daten. Scikit-learn's IterativeImputer implementiert einen MICE-Ansatz (Multiple Imputation by Chained Equations): Für jede Spalte mit fehlenden Werten wird ein Modell als Funktion der anderen Spalten erstellt, und die Imputation wird wiederholt, bis die Werte konvergieren. Dadurch werden Beziehungen zwischen Merkmalen besser erfasst als mit einspaltigen Strategien.

import pandas as pd
import numpy as np
from sklearn.experimental import enable_iterative_imputer  # noqa
from sklearn.impute import IterativeImputer

df = pd.DataFrame({
    'x1': [1, 2, np.nan, 4, 5],
    'x2': [2, np.nan, 6, 8, 10],
    'y':  [3, 5, 7, np.nan, 11]
})

imp = IterativeImputer(max_iter=10, random_state=0)
df_filled = pd.DataFrame(imp.fit_transform(df), columns=df.columns)
print(df_filled.round(2))

Indikatorspalten für fehlende Daten

Anstatt die Tatsache zu verbergen, dass ein Wert imputiert wurde, empfiehlt es sich, eine binäre Indikatorspalte hinzuzufügen, die markiert, in welchen Zeilen vor der Imputation Werte fehlten. So können nachgelagerte Modelle aus dem Muster der fehlenden Werte selbst lernen – manchmal ist die Information, ob ein Wert fehlt, genauso aussagekräftig wie der Wert selbst.

import pandas as pd
import numpy as np

df = pd.DataFrame({'salary': [50000, np.nan, 70000, np.nan, 90000]})

# Add indicator before filling
df['salary_was_missing'] = df['salary'].isna().astype(int)

# Then fill
df['salary'] = df['salary'].fillna(df['salary'].median())
print(df)
#    salary  salary_was_missing
# 0  50000.0                   0
# 1  70000.0                   1
# 2  70000.0                   0
# 3  70000.0                   1
# 4  90000.0                   0

Imputation und Data Leakage

Eine entscheidende Regel in Machine-Learning-Pipelines lautet: Berechnen Sie Imputationsstatistiken (Mittelwert, Median, Modus) nur auf dem Trainingsdatensatz und wenden Sie anschließend dieselben Werte auf den Testdatensatz an. Werden Statistiken vor der Aufteilung anhand des vollständigen Datensatzes berechnet, entsteht Data Leakage – das Modell sieht während des Trainings indirekt Testdaten, wodurch Leistungsschätzungen zu hoch ausfallen. Fitten Sie Imputer immer mit den Trainingsdaten und transformieren Sie sowohl Trainings- als auch Testdaten.

import pandas as pd
import numpy as np
from sklearn.impute import SimpleImputer
from sklearn.model_selection import train_test_split

df = pd.DataFrame({'feature': [1, 2, np.nan, 4, np.nan, 6, 7, 8]})
train, test = train_test_split(df, test_size=0.25, random_state=0)

# Fit ONLY on training data
imp = SimpleImputer(strategy='mean')
train['feature'] = imp.fit_transform(train[['feature']])

# Transform test using training statistics
test['feature'] = imp.transform(test[['feature']])
print('Train mean used:', imp.statistics_[0])

Imputationsstrategien visuell vergleichen

Vergleichen Sie nach der Anwendung mehrerer Imputationsmethoden deren Auswirkungen, indem Sie die Verteilungen der ursprünglichen und imputierten Spalten nebeneinander darstellen. Eine gute Imputation sollte die Form (Mittelwert, Varianz, Schiefe) der ursprünglichen Verteilung möglichst gut erhalten. Eine Mittelwert-Imputation verengt die Verteilung; KNN und MICE erhalten sie in der Regel besser.

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

np.random.seed(0)
original = np.random.exponential(scale=5, size=200)
with_nan = original.copy()
with_nan[np.random.choice(200, 40, replace=False)] = np.nan

s = pd.Series(with_nan)

fig, axes = plt.subplots(1, 2, figsize=(10, 4))
s.dropna().hist(ax=axes[0], bins=20, title='Original (no NaN)')
s.fillna(s.mean()).hist(ax=axes[1], bins=20, title='Mean-imputed')
plt.tight_layout()
plt.savefig('imputation_comparison.png')
print('Saved comparison chart')

Die richtige Imputationsstrategie auswählen

Es gibt keine allgemein beste Imputationsstrategie – die richtige Wahl hängt vom Kontext ab. Verwenden Sie mean/median für einfache univariate Fälle mit wenigen fehlenden Werten. Verwenden Sie ffill/bfill für Zeitreihen mit stabilen Trends. Verwenden Sie KNN oder IterativeImputer, wenn Merkmale korreliert sind und Sie diese Beziehungen nutzen möchten. Verwenden Sie domänenspezifische Konstanten (z. B. 0 für nicht vorhanden, -1 für unbekannt), wenn der fehlende Wert eine eindeutige fachliche Bedeutung hat. Dokumentieren Sie Ihre Wahl immer.

# Decision guide (no runnable code)
#
# Missing < 5%  AND data is MCAR?  -> Mean/median fill is fine
# Time series with stable trend?   -> ffill() with limit
# Features are correlated?         -> KNNImputer or IterativeImputer
# Categorical column?              -> Mode fill or 'Unknown' sentinel
# Going into ML model?             -> Add indicator column + fill
# Research / publication quality?  -> Multiple imputation (MICE)
print('Strategy selected based on context')

Schnelltest

Testen Sie Ihr Verständnis von Interpolation und fortgeschrittener Imputation.

Zusammenfassung der Lektion

In dieser Lektion haben Sie gelernt: interpolate() schätzt fehlende Werte, indem ein gleichmäßiger Trend zwischen bekannten Werten angenommen wird, method='time' verarbeitet ungleichmäßige Abstände in einem DatetimeIndex und fortgeschrittene Strategien wie KNNImputer und IterativeImputer nutzen andere Spalten, um Ersatzwerte zu bestimmen. Fügen Sie vor der Imputation immer Indikatorspalten hinzu und berechnen Sie Statistiken ausschließlich auf dem Trainingsdatensatz, um Data Leakage zu vermeiden. Als Nächstes untersuchen und konvertieren wir die Datentypen von DataFrame-Spalten.

Häufig gestellte Fragen

Ist die Lektion „Interpolation und fortgeschrittene Imputation“ kostenlos?

Ja — der vollständige Text von „Interpolation und fortgeschrittene Imputation“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Pandas & NumPy Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Pandas & NumPy Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Interpolation und fortgeschrittene Imputation“?

Verwenden Sie interpolate() zum gleichmäßigen zeitbasierten Auffüllen und lernen Sie, wann eine Imputation mit Mittelwert oder Median sinnvoll ist. Du übst Pandas & NumPy Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Pandas & NumPy Academy zu starten?

Keine Vorkenntnisse erforderlich. Pandas & NumPy Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 4 von 4.

Wie lange dauert die Lektion „Interpolation und fortgeschrittene Imputation“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Pandas & NumPy Academy-Lektion Code schreiben und ausführen?

Ja. Jede Pandas & NumPy Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

  1. Fehlende Werte erkennen
  2. Fehlende Werte entfernen
  3. Fehlende Werte auffüllen
  4. Interpolation und fortgeschrittene Imputation
← Zurück zu Pandas & NumPy Academy