Feature-Selection-Tutorial in Python: Der Einsteiger-Guide

Lerne die Grundlagen der Feature Selection kennen und wie du verschiedene Verfahren in Python umsetzt und analysierst.

Aktualisiert 18. Sept. 2026 · 14 Min. lesen

Mit KI erkunden

Code aus diesem Tutorial online ausführen und bearbeiten

Wenn du mehr in Python lernen willst, probiere DataCamps kostenlosen Kurs Intro to Python for Data Science aus.

Ihr kennt alle Datensätze. Manchmal sind sie klein, oft aber auch riesig. Sehr große Datensätze zu verarbeiten ist herausfordernd und kann schnell zum Flaschenhals werden.

Was macht diese Datensätze so groß? Die Features. Je mehr Features, desto größer der Datensatz. Nun, nicht immer: Es gibt Datensätze mit vielen Features, aber wenigen Instanzen. Darum geht es hier aber nicht. Vielmehr fragst du dich vielleicht, wie du solche Datensätze auf einem normalen Rechner effizient verarbeitest, ohne dich zu verzetteln.

In hochdimensionalen Datensätzen finden sich oft völlig irrelevante, unbedeutende und unwichtige Features. Deren Beitrag zur Vorhersageleistung ist in der Regel geringer als der kritischer Merkmale – manchmal sogar gleich null. Diese Features verursachen Probleme, die eine effiziente Modellierung behindern:

Unnötige Ressourcenbindung für diese Features.
Sie fungieren als Rauschen, wodurch das Machine-Learning-Modell deutlich schlechter abschneidet.
Das Modell braucht länger zum Trainieren.

Also, was tun? Die wirtschaftlichste Lösung ist die Feature Selection.

Feature Selection ist der Prozess, aus einem Datensatz die aussagekräftigsten Merkmale auszuwählen. In vielen Fällen verbessert sie auch die Performance eines Machine-Learning-Modells.

Klingt spannend, oder?

Du hast jetzt eine informelle Einführung in Feature Selection und ihre Bedeutung in Data Science und Machine Learning bekommen. In diesem Beitrag behandelst du:

Einführung in Feature Selection und warum sie wichtig ist
Unterschied zwischen Feature Selection und Dimensionalitätsreduktion
Verschiedene Arten von Feature-Selection-Methoden
Umsetzung verschiedener Feature-Selection-Methoden mit scikit-learn

Einführung in Feature Selection

Feature Selection ist auch als Variablenselektion oder Attributselektion bekannt.

Im Kern geht es darum, die wichtigsten bzw. relevantesten Features eines Datensatzes auszuwählen.

Warum Feature Selection wichtig ist

Die Bedeutung zeigt sich besonders bei Datensätzen mit sehr vielen Merkmalen – sogenannten hochdimensionalen Datensätzen. Hohe Dimensionalität erhöht die Trainingszeit deines Modells deutlich, macht es komplexer und begünstigt Overfitting.

In solchen Feature-Sets sind häufig Merkmale enthalten, die redundant sind, also lediglich Erweiterungen anderer essenzieller Features. Redundante Features tragen kaum zum Training bei. Es ist daher sinnvoll, die wichtigsten und relevantesten Features zu extrahieren, um die Vorhersageleistung zu maximieren.

"Das Ziel der Variablenselektion ist dreifach: die Vorhersageleistung zu verbessern, schnellere und kostengünstigere Prädiktoren zu ermöglichen und ein besseres Verständnis des zugrunde liegenden Prozesses zu schaffen, der die Daten generiert hat."

-An Introduction to Variable and Feature Selection

Als Nächstes klären wir den Unterschied zwischen Dimensionalitätsreduktion und Feature Selection.

Feature Selection wird manchmal mit Dimensionalitätsreduktion verwechselt – es sind jedoch verschiedene Ansätze. Beide reduzieren die Anzahl der Attribute, aber Dimensionalitätsreduktion erzeugt neue Kombinationen von Attributen (Feature Transformation), während Feature Selection vorhandene Attribute unverändert ein- oder ausschließt.

Beispiele für Dimensionalitätsreduktion sind Principal Component Analysis, Singular Value Decomposition, Linear Discriminant Analysis usw.

Die wichtigsten Punkte zur Feature Selection zusammengefasst:

Ermöglicht schnelleres Training.
Reduziert die Modellkomplexität und erleichtert die Interpretation.
Kann die Genauigkeit verbessern, wenn die richtige Teilmenge gewählt wird.
Verringert Overfitting.

Im nächsten Abschnitt lernst du die allgemeinen Methoden kennen: Filter-, Wrapper- und Embedded-Methoden.

Filter-Methoden

Die folgende Grafik beschreibt Filter-basierte Feature-Selection-Methoden am besten:

Bildquelle: Analytics Vidhya

Filter-Methoden stützen sich auf die allgemeinen Eigenschaften der Daten, um eine Feature-Teilmenge auszuwählen, ohne ein Lernverfahren einzubeziehen. Sie verwenden Bewertungsmaße wie Distanz, Information, Abhängigkeit und Konsistenz. Typisch ist ein Ranking-Verfahren: Features werden bewertet und der Rang dient als Auswahlkriterium. Vorteil: Einfachheit und gute, relevante Merkmale. Irrelevante Features werden vor der Klassifikation herausgefiltert.

Filter-Methoden werden meist als Datenvorverarbeitung eingesetzt. Die Auswahl ist unabhängig von einem bestimmten Machine-Learning-Algorithmus. Features erhalten Rangwerte auf Basis statistischer Kennzahlen, die ihre Korrelation mit der Zielvariable ausdrücken. Korrelation ist kontextabhängig und variiert je nach Aufgabe. Die folgende Tabelle zeigt gebräuchliche Korrelationskoeffizienten für unterschiedliche Datentypen (hier kontinuierlich und kategorial).

table for defining correlation coefficients for different types of data

Bildquelle: Analytics Vidhya

Beispiele für Filter-Methoden sind der Chi-Quadrat-Test, Information Gain und Korrelationskoeffizienten.

Als Nächstes schauen wir uns Wrapper-Methoden an.

Wrapper-Methoden

Wie bei den Filter-Methoden hilft dir auch hier eine Infografik beim Verständnis der Wrapper-Methoden:

Bildquelle: Analytics Vidhya

Eine Wrapper-Methode nutzt einen Machine-Learning-Algorithmus und bewertet Features anhand seiner Performance. Sie sucht die am besten geeigneten Merkmale für den Algorithmus, um die Vorhersageleistung zu steigern. Zur Bewertung werden z. B. die Vorhersagegenauigkeit bei Klassifikation oder die Cluster-Güte beim Clustering herangezogen.

Typische Beispiele sind Forward Feature Selection, Backward Feature Elimination und Recursive Feature Elimination.

Forward Selection: Start mit leerem Feature-Set. Das beste Originalfeature wird ermittelt und hinzugefügt. In jeder weiteren Iteration kommt das jeweils beste verbleibende Attribut dazu.
Backward Elimination: Start mit dem vollständigen Attributset. In jedem Schritt wird das schlechteste Attribut entfernt.
Kombination aus Forward und Backward: In jedem Schritt wird das beste Attribut hinzugefügt und das schlechteste der verbleibenden entfernt.
Recursive Feature Elimination: RFE führt eine gierige Suche durch, um die beste Feature-Teilmenge zu finden. Es erstellt iterativ Modelle und identifiziert in jeder Iteration das beste oder schlechteste Feature, baut dann mit den verbleibenden Features weiter, bis alle geprüft sind, und rankt sie nach Eliminationsreihenfolge. Im Worst Case prüft RFE bei N Features bis zu 2^N Kombinationen.

Klingt gut!

Weiter geht’s mit Embedded-Methoden.

Embedded-Methoden

Embedded-Methoden sind iterativ und berücksichtigen jede Trainingsiteration des Modells. Sie extrahieren gezielt die Features, die in der jeweiligen Iteration am meisten beitragen. Am häufigsten kommen Regularisierungsmethoden zum Einsatz, die Features über Schwellwerte für Koeffizienten bestrafen.

Darum heißen Regularisierungsmethoden auch Penalization-Methoden: Sie fügen bei der Optimierung eines Prädiktionsverfahrens (z. B. Regression) zusätzliche Nebenbedingungen hinzu und steuern das Modell in Richtung geringerer Komplexität (weniger bzw. kleinere Koeffizienten).

Beispiele sind LASSO, Elastic Net und Ridge Regression.

Unterschied zwischen Filter- und Wrapper-Methoden

Die Abgrenzung kann verwirrend sein. Hier die zentralen Unterschiede:

Filter-Methoden verwenden kein ML-Modell zur Bewertung von Features, Wrapper-Methoden schon – sie trainieren ein Modell und entscheiden so über die Relevanz.
Filter-Methoden sind deutlich schneller, da kein Training nötig ist. Wrapper-Methoden sind rechenintensiv und bei sehr großen Datensätzen oft ungeeignet.
Fehlt es an Daten, können Filter-Methoden die beste Feature-Teilmenge verfehlen, weil statistische Zusammenhänge nicht zuverlässig modelliert werden. Wrapper-Methoden finden durch ihre umfassende Suche eher die beste Teilmenge.
Die Verwendung von Wrapper-Features im finalen Modell kann zu Overfitting führen, da das Modell die Features schon während der Auswahl „gesehen“ hat. Features aus Filter-Methoden führen in den meisten Fällen nicht zu Overfitting.

Bis hierhin hast du die Bedeutung der Feature Selection verstanden und sie von Dimensionalitätsreduktion abgegrenzt. Außerdem kennst du die wichtigsten Methoden. Soweit, so gut!

Jetzt noch ein paar Stolperfallen bei der Anwendung:

Wichtiger Hinweis

Du kennst nun den Nutzen von Feature Selection im ML-Pipeline und was sie leistet. Entscheidend ist, an welcher Stelle du sie integrierst.

Grundregel: Führe Feature Selection vor dem Training im jeweiligen Trainingsfold durch, insbesondere wenn du Genauigkeit mit Cross-Validation schätzt. So wird die Auswahl nur auf dem Trainingsanteil vorgenommen. Wenn du jedoch erst auf dem gesamten Datensatz Feature Selection machst und danach Modellwahl und Training auf den ausgewählten Features, ist das ein grober Fehler.

Wendest du Feature Selection auf alle Daten an und validierst dann per Cross-Validation, fließen Informationen aus den Testfolds in die Featureauswahl ein. Das verzerrt die Performance-Schätzung deines Modells.

Genug Theorie. Jetzt wird gecodet.

Case Study in Python

Für die Case Study nutzt du den Pima Indians Diabetes Datensatz. Die Beschreibung findest du hier.

Es handelt sich um eine Klassifikationsaufgabe: Anhand von 8 Features soll vorhergesagt werden, ob eine Person Diabetes hat.

Der Datensatz umfasst 768 Beobachtungen. Zuerst lädst du den Datensatz. Vorher importieren wir die benötigten Abhängigkeiten. Weitere kannst du später nachladen.

import pandas as pd
import numpy as np

Jetzt lädst du den Pima-Indians-Datensatz in ein DataFrame-Objekt mit Pandas.

data = pd.read_csv("diabetes.csv")

Der Datensatz ist nun im DataFrame data. Schauen wir kurz rein.

data.head()

Du siehst 8 Features und die Zielvariable 1/0, wobei 1 für Diabetes steht und 0 für kein Diabetes. Der Datensatz enthält fehlende Werte: Bestimmte Spalten haben Nullwerte, die aufgrund der Definition unplausibel sind (z. B. 0 beim Body-Mass-Index oder Blutdruck).

Für dieses Tutorial nutzen wir direkt eine vorverarbeitete Version des Datensatzes.

# load data
url = "https://raw.githubusercontent.com/jbrownlee/Datasets/master/pima-indians-diabetes.data.csv"
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
dataframe = pd.read_csv(url, names=names)

Die Daten liegen nun im DataFrame dataframe.

Konvertieren wir ihn für schnellere Berechnungen in ein NumPy-Array und trennen Features und Labels.

array = dataframe.values
X = array[:,0:8]
Y = array[:,8]

Super, die Daten sind vorbereitet.

Zuerst führst du einen Chi-Quadrat-Test für nicht-negative Features durch, um die 4 besten Merkmale zu wählen. Du weißt schon: Chi-Quadrat gehört zu den Filter-Methoden. Wer die Details auffrischen will: Dieses Video erklärt es hervorragend.

scikit-learn bietet die Klasse SelectKBest, die mit verschiedenen statistischen Tests eine feste Anzahl an Features auswählt – hier via Chi-Quadrat.

# Import the necessary libraries first
from sklearn.feature_selection import SelectKBest
from sklearn.feature_selection import chi2

Bibliotheken sind importiert – los geht’s.

# Feature extraction
test = SelectKBest(score_func=chi2, k=4)
fit = test.fit(X, Y)

# Summarize scores
np.set_printoptions(precision=3)
print(fit.scores_)

features = fit.transform(X)
# Summarize selected features
print(features[0:5,:])

[ 111.52  1411.887   17.605   53.108 2175.565  127.669    5.393  181.304]
[[148.    0.   33.6  50. ]
 [ 85.    0.   26.6  31. ]
 [183.    0.   23.3  32. ]
 [ 89.   94.   28.1  21. ]
 [137.  168.   43.1  33. ]]

Interpretation:

Du siehst die Scores je Attribut und die 4 ausgewählten Merkmale mit den höchsten Werten: plas, test, mass und age. Diese Scores helfen dir, die besten Features für das Training zu bestimmen.

Hinweis: Die erste Zeile bezeichnet die Features. Für die Vorverarbeitung wurden die Namen numerisch kodiert.

Als Nächstes implementierst du die Recursive Feature Elimination, eine Wrapper-Methode.

RFE entfernt rekursiv Attribute und baut jeweils ein Modell auf den verbleibenden Merkmalen.

Die Modellgenauigkeit dient als Kriterium, um zu erkennen, welche Attribute (und Kombinationen) am meisten zur Vorhersage beitragen.

Mehr zur Klasse RFE findest du in der scikit-learn-Dokumentation.

# Import your necessary dependencies
from sklearn.feature_selection import RFE
from sklearn.linear_model import LogisticRegression

Wir nutzen RFE mit dem Klassifikator Logistic Regression, um die Top 3 Features zu wählen. Die konkrete Algorithmuswahl ist zweitrangig – Hauptsache solide und konsistent.

# Feature extraction
model = LogisticRegression()
rfe = RFE(model, 3)
fit = rfe.fit(X, Y)
print("Num Features: %s" % (fit.n_features_))
print("Selected Features: %s" % (fit.support_))
print("Feature Ranking: %s" % (fit.ranking_))

Num Features: 3
Selected Features: [ True False False False False  True  True False]
Feature Ranking: [1 2 3 5 6 1 1 4]

RFE hat die Top 3 Features als preg, mass und pedi ausgewählt.

Diese sind im Array support mit True markiert und im ranking-Array mit „1“ gekennzeichnet – ein Indikator für ihre Stärke.

Als Nächstes nutzt du die Ridge Regression, eine Regularisierungstechnik und damit auch eine Embedded-Methode.

Dieser Artikel bietet eine sehr gute Einführung in Ridge Regression.

# First things first
from sklearn.linear_model import Ridge

Im Anschluss verwendest du Ridge Regression und bestimmst die Koeffizienten.

Sieh dir auch die offizielle scikit-learn-Doku zu Ridge Regression an.

ridge = Ridge(alpha=1.0)
ridge.fit(X,Y)

Ridge(alpha=1.0, copy_X=True, fit_intercept=True, max_iter=None,
   normalize=False, random_state=None, solver='auto', tol=0.001)

Zur besseren Interpretation implementieren wir eine kleine Helferfunktion, die die Koeffizienten übersichtlich ausgibt.

# A helper method for pretty-printing the coefficients
def pretty_print_coefs(coefs, names = None, sort = False):
    if names == None:
        names = ["X%s" % x for x in range(len(coefs))]
    lst = zip(coefs, names)
    if sort:
        lst = sorted(lst,  key = lambda x:-np.abs(x[0]))
    return " + ".join("%s * %s" % (round(coef, 3), name)
                                   for coef, name in lst)

Nun übergeben wir die Koeffizienten des Ridge-Modells an diese Funktion.

print ("Ridge model:", pretty_print_coefs(ridge.coef_))

Ridge model: 0.021 * X0 + 0.006 * X1 + -0.002 * X2 + 0.0 * X3 + -0.0 * X4 + 0.013 * X5 + 0.145 * X6 + 0.003 * X7

Du siehst alle Koeffizienten zusammen mit den jeweiligen Feature-Variablen. Das hilft erneut bei der Auswahl der wichtigsten Merkmale. Merke dir zu Ridge Regression:

Auch bekannt als L2-Regularisierung.
Stark korrelierte Features erhalten oft ähnliche Koeffizienten.
Features mit negativen Koeffizienten tragen tendenziell weniger bei. Bei vielen Merkmalen hilft die Größe der Koeffizienten bei der finalen Auswahl.

Damit ist die Case Study abgeschlossen. Die gezeigten Methoden helfen dir, die Merkmale eines Datensatzes umfassend zu bewerten. Noch ein paar Kernpunkte:

Feature Selection ist Teil der Datenvorverarbeitung – oft der zeitaufwendigste Schritt in einer ML-Pipeline.
Mit diesen Techniken gehst du systematisch und ML-freundlich vor und interpretierst Features zuverlässiger.

Fazit

In diesem Beitrag hast du Feature Selection als eines der meist erforschten statistischen Themen kennengelernt, die Varianten verglichen und angewendet, um wichtige Merkmale in einem Datensatz zu identifizieren.

Du kannst das Tutorial erweitern, indem du z. B. ein Korrelationsmaß in die Wrapper-Methode integrierst und die Wirkung testest. Vielleicht entwickelst du so deinen eigenen Auswahlmechanismus – ein solider Start für eigene Recherchen. Forschende setzen auch Soft Computing-Ansätze ein. Probiere bestehende Algorithmen auf verschiedenen Datensätzen aus und ziehe eigene Schlüsse.

Warum sind traditionelle Feature-Selection-Methoden weiterhin relevant?

Gute Frage. Zwar können neuronale Netze (z. B. CNNs) wichtige Features automatisch extrahieren, aber auch sie haben Grenzen. Für gewöhnliche tabellarische Daten ohne bildtypische Eigenschaften (Translation, Kanten, Positionen, Konturen usw.) ist ein CNN selten die beste Wahl. Mit wenig Daten und begrenzten Ressourcen kann das Training zudem reine Verschwendung sein. Genau in solchen Situationen leisten die hier besprochenen Methoden hervorragende Dienste.

Hier ein paar Ressourcen, wenn du tiefer einsteigen willst:

Folgende Referenzen wurden für dieses Tutorial herangezogen: