Python
Leichtes Codieren kategorischer Daten mit pd.get_dummies

Leichtes Codieren kategorischer Daten mit pd.get_dummies

MoeNagy Dev

Was ist pd.get_dummies?

Understanding the purpose of pd.get_dummies

pd.get_dummies ist eine Funktion in der Pandas-Bibliothek, die verwendet wird, um kategorische Variablen in numerische Dummy-Variablen umzuwandeln. Dies ist eine gängige Technik in der Datenverarbeitung, insbesondere für Machine-Learning-Modelle, da die meisten Modelle numerische Eingabemerkmale erfordern.

Die Funktion pd.get_dummies nimmt ein Pandas DataFrame oder eine Series als Eingabe und erstellt ein neues DataFrame, in dem jede eindeutige Kategorie als binäre Spalte dargestellt wird. Eine 1 gibt an, dass die Kategorie vorhanden ist, und eine 0 gibt an, dass sie nicht vorhanden ist.

Situationen, in denen pd.get_dummies nützlich ist

pd.get_dummies ist besonders nützlich in den folgenden Situationen:

  1. Handling kategorischer Variablen: Wenn Sie kategorische Variablen in Ihrem Datensatz haben, wie z.B. Geschlecht, Stadt oder Produkttyp, müssen Sie sie in ein Format umwandeln, das von Machine-Learning-Algorithmen verstanden werden kann, die in der Regel mit numerischen Daten arbeiten.

  2. Vorbereitung von Daten für Machine Learning: Viele Machine-Learning-Modelle wie lineare Regression, logistische Regression und Entscheidungsbäume erfordern numerische Eingaben. pd.get_dummies ermöglicht es Ihnen, kategorische Variablen in ein Format zu transformieren, das als Merkmale in diesen Modellen verwendet werden kann.

  3. Exploratory Data Analysis: Das Codieren kategorischer Variablen mit pd.get_dummies kann Ihnen helfen, die Beziehungen zwischen verschiedenen Kategorien und der Zielvariable besser zu verstehen, was während der explorativen Datenanalyse (EDA) hilfreich ist.

  4. Verbesserung der Modellleistung: Durch das Codieren kategorischer Variablen können Sie die Leistung Ihrer Machine-Learning-Modelle verbessern, da sie die zugrunde liegenden Muster in den Daten besser erfassen können.

Verwendung von pd.get_dummies

Identifizieren kategorischer Variablen in einem DataFrame

Bevor Sie pd.get_dummies verwenden können, müssen Sie die kategorischen Variablen in Ihrem DataFrame identifizieren. Dies können Sie tun, indem Sie die Datentypen der Spalten überprüfen:

import pandas as pd
 
# Datensatz laden
df = pd.read_csv('your_dataset.csv')
 
# Kategorische Spalten identifizieren
kategoriale_spalten = df.select_dtypes(include=['object', 'category']).columns
print(kategoriale_spalten)

Dieser Code gibt die Namen der kategorischen Spalten in Ihrem DataFrame aus.

Anwenden von pd.get_dummies auf ein DataFrame

Sobald Sie die kategorischen Variablen identifiziert haben, können Sie pd.get_dummies verwenden, um sie zu codieren:

# pd.get_dummies auf das DataFrame anwenden
codiertes_df = pd.get_dummies(df, columns=kategoriale_spalten)

Dies erstellt ein neues DataFrame codiertes_df mit den kategorischen Variablen kodiert als binäre Spalten.

Das Ausgabeergebnis von pd.get_dummies verstehen

Die Ausgabe von pd.get_dummies ist ein DataFrame mit derselben Anzahl von Zeilen wie das ursprüngliche DataFrame, aber mit zusätzlichen Spalten für jede eindeutige Kategorie in der kodierten Variable/n.

Wenn Sie z.B. eine 'Geschlecht'-Spalte mit den Werten 'männlich' und 'weiblich' hätten, würde das Ausgabe-DataFrame zwei neue Spalten haben: 'Geschlecht_männlich' und 'Geschlecht_weiblich', mit Werten von 0 oder 1, die das Vorhandensein oder Fehlen jeder Kategorie anzeigen.

Anpassen von pd.get_dummies

Festlegen der zu codierenden Spalten

Wenn Sie nur eine Teilmenge der kategorischen Variablen in Ihrem DataFrame codieren möchten, können Sie die zu codierenden Spalten mit dem columns-Parameter angeben:

# Nur die 'Geschlecht'- und 'Stadt'-Spalten codieren
codiertes_df = pd.get_dummies(df, columns=['Geschlecht', 'Stadt'])

Umgang mit fehlenden Werten

Wenn Ihr Datensatz fehlende Werte in den kategorischen Variablen enthält, wird pd.get_dummies standardmäßig eine zusätzliche Spalte für die fehlenden Werte erstellen. Sie können dieses Verhalten mit dem dummy_na-Parameter steuern:

# Die Spalte für den fehlenden Wert ausschließen
codiertes_df = pd.get_dummies(df, columns=kategoriale_spalten, dummy_na=False)
 
# Die Spalte für den fehlenden Wert einschließen
codiertes_df = pd.get_dummies(df, columns=kategoriale_spalten, dummy_na=True)

Steuern der Benennung von Dummy-Spalten

Standardmäßig benennt pd.get_dummies die Dummy-Spalten als 'spaltenname_kategoriename'. Sie können die Benennung mit den Parametern prefix und prefix_sep anpassen:

# Anpassen der Spaltennamen
codiertes_df = pd.get_dummies(df, columns=kategoriale_spalten, prefix_sep='_', prefix='cat')

Dies erstellt Spalten mit den Namen 'cat_Geschlecht_männlich', 'cat_Geschlecht_weiblich', usw.

Fortgeschrittene Techniken mit pd.get_dummies

Codierung mehrerer kategorischer Variablen

Wenn Sie mehrere kategorische Variablen in Ihrem DataFrame haben, können Sie sie alle gleichzeitig mit pd.get_dummies kodieren:

# Mehrere kategorische Variablen kodieren
codiertes_df = pd.get_dummies(df, columns=kategoriale_spalten)

Dies erstellt Dummy-Spalten für alle eindeutigen Kategorien über die angegebenen Spalten hinweg.

Umgang mit kategorischen Variablen mit hoher Kardinalität

Kategorische Variablen mit hoher Kardinalität, die eine große Anzahl eindeutiger Kategorien haben, können zu einer sehr großen Anzahl von Dummy-Spalten führen, die rechenintensiv sein und die Modellleistung negativ beeinflussen können. In solchen Fällen können Sie alternative Codierungstechniken wie ordinale Codierung oder Zielcodierung in Betracht ziehen.

Kombination von pd.get_dummies mit anderen Daten Transformationstechniken

pd.get_dummies kann mit anderen Daten-Transformationstechniken wie Skalierung oder Normalisierung kombiniert werden, um Ihre Daten für Machine-Learning-Modelle vorzubereiten. Zum Beispiel:

from sklearn.preprocessing import StandardScaler
 
# Kategoriale Variablen kodieren
codiertes_df = pd.get_dummies(df, columns=kategoriale_spalten)
# Skaliere die numerischen Merkmale
scaler = StandardScaler()
encoded_df[numerical_cols] = scaler.fit_transform(encoded_df[numerical_cols])

Dies erstellt das verschlüsselte DataFrame und skaliert dann die numerischen Merkmale mithilfe des StandardScaler aus scikit-learn.

Interpretation der Ergebnisse von pd.get_dummies

Verständnis der Struktur des verschlüsselten DataFrames

Die Ausgabe von pd.get_dummies ist ein DataFrame mit derselben Anzahl von Zeilen wie das ursprüngliche DataFrame, aber mit zusätzlichen Spalten für jede eindeutige Kategorie in der/en verschlüsselten Variable(n). Es ist wichtig, die Struktur dieses verschlüsselten DataFrames zu verstehen, da es als Eingabe für Ihre Machine-Learning-Modelle dienen wird.

Analyse der Auswirkungen der Codierung auf die Daten

Nach der Anwendung von pd.get_dummies sollten Sie die Auswirkungen der Codierung auf Ihre Daten analysieren. Dies kann Folgendes umfassen:

  • Überprüfung von Änderungen an den statistischen Eigenschaften der Daten (z. B. Durchschnitt, Standardabweichung)
  • Visualisierung der Verteilung der verschlüsselten Merkmale
  • Untersuchung der Korrelation zwischen den verschlüsselten Merkmalen und der Zielvariablen

Diese Analyse kann Ihnen helfen zu verstehen, wie sich die Codierung auf Ihre Daten ausgewirkt hat und ob weitere Vorverarbeitungsschritte erforderlich sind.

Best Practices und Überlegungen

Identifizierung, wann pd.get_dummies geeignet ist

pd.get_dummies ist ein leistungsstarkes Werkzeug, aber es ist wichtig, es sorgfältig einzusetzen. Es ist möglicherweise nicht in allen Situationen die beste Wahl, insbesondere beim Umgang mit Kategorienvariablen mit hoher Kardinalität oder ordinalen Kategorienvariablen.

Umgang mit kategorialen Variablen in Machine-Learning-Modellen

Wenn Sie das verschlüsselte DataFrame als Eingabe für Machine-Learning-Modelle verwenden, sollten Sie sich der Annahmen und Anforderungen des spezifischen Modells bewusst sein, das Sie verwenden. Manche Modelle, wie Entscheidungsbäume und Random Forests, können kategorische Variablen direkt verarbeiten, während andere, wie lineare Regression, die Verwendung von Dummy-Variablen erfordern können.

Kombinieren von pd.get_dummies mit anderen Codierungstechniken

pd.get_dummies ist eine von mehreren Techniken zur Codierung von kategorialen Variablen. Abhängig von den Eigenschaften Ihrer Daten und den Anforderungen Ihres Machine-Learning-Modells müssen Sie möglicherweise pd.get_dummies mit anderen Codierungstechniken kombinieren, wie z. B. Label-Encoding oder ordinaler Codierung.

Alternativen zu pd.get_dummies

Obwohl pd.get_dummies eine weit verbreitete und effektive Technik zur Codierung kategorialer Variablen ist, stehen andere Codierungsmethoden zur Verfügung, von denen jede ihre eigenen Stärken und Schwächen hat. Einige Alternativen sind:

  1. Label-Encoding: Diese Technik weist jeder Kategorie einen eindeutigen numerischen Label zu, was für ordinale kategorische Variablen nützlich sein kann.
  2. Ordinale Codierung: Diese Methode ähnelt dem Label-Encoding, jedoch werden die numerischen Labels basierend auf der inhärenten Reihenfolge der Kategorien zugewiesen.
  3. Target-Encoding: Dieser Ansatz ersetzt jede Kategorie durch den Mittelwert oder Median der Zielvariablen für diese Kategorie, was für Kategorienvariablen mit hoher Kardinalität nützlich sein kann.
  4. One-Hot-Encoding: Dies ähnelt pd.get_dummies, erstellt jedoch Binärspalten für jede Kategorie, einschließlich der Kategorie für fehlende Werte.

Die Wahl der Codierungstechnik hängt von den Eigenschaften Ihrer Daten und den Anforderungen Ihres Machine-Learning-Modells ab.

Fazit

In diesem Tutorial haben Sie die pd.get_dummies-Funktion in Pandas kennengelernt und gelernt, wie Sie kategoriale Variablen in einem Format codieren können, das für Machine-Learning-Modelle geeignet ist. Sie haben den Zweck von pd.get_dummies erkundet, wie Sie es verwenden können und wie Sie es an Ihre spezifischen Bedürfnisse anpassen können. Sie haben auch einige fortgeschrittene Techniken und bewährte Praktiken sowie Alternativen zu pd.get_dummies gesehen.

Durch das Beherrschen der Verwendung von pd.get_dummies sind Sie besser gerüstet, um kategorische Variablen in Ihren Datenverarbeitungs- und Machine-Learning-Workflows zu behandeln. Denken Sie daran, immer die Auswirkungen der Codierung auf Ihre Daten zu analysieren und die geeignete Codierungstechnik basierend auf den Eigenschaften Ihres Datensatzes und den Anforderungen Ihrer Modelle auszuwählen.

Funktionen

Funktionen in Python sind Blöcke von wiederverwendbarem Code, die eine bestimmte Aufgabe erledigen. Sie können Argumente entgegennehmen, Operationen durchführen und Werte zurückgeben. Hier ist ein Beispiel für eine einfache Funktion, die den Flächeninhalt eines Rechtecks berechnet:

def calculate_area(length, width):
    area = length * width
    return area
 
# Rufe die Funktion auf
rectangle_area = calculate_area(5, 10)
print(rectangle_area)  # Ausgabe: 50

In diesem Beispiel nimmt die Funktion calculate_area zwei Argumente, length und width, entgegen und gibt den berechneten Flächeninhalt zurück. Sie können die Funktion dann aufrufen und das Ergebnis in einer Variablen speichern.

Funktionen können auch optionale Parameter mit Standardwerten haben:

def greet(name, message="Hello"):
    print(f"{message}, {name}!")
 
greet("Alice")  # Ausgabe: Hello, Alice!
greet("Bob", "Hi")  # Ausgabe: Hi, Bob!

In diesem Beispiel hat der Parameter message einen Standardwert von "Hello", sodass Sie die Funktion nur mit dem Argument name aufrufen können und sie den Standardgruß verwendet.

Module und Pakete

Die Python-Standardbibliothek bietet eine Vielzahl von Modulen, die Sie in Ihren Programmen verwenden können. Sie können auch Ihre eigenen Module und Pakete erstellen, um Ihren Code zu organisieren.

Um ein Modul zu verwenden, können Sie es mit der import-Anweisung importieren:

import math
 
# Verwende Funktionen aus dem math-Modul
print(math.pi)  # Ausgabe: 3.141592653589793
print(math.sqrt(16))  # Ausgabe: 4.0

Sie können auch bestimmte Funktionen oder Attribute aus einem Modul importieren:

from math import pi, sqrt
 
print(pi)  # Ausgabe: 3.141592653589793
print(sqrt(16))  # Ausgabe: 4.0

Pakete sind Sammlungen von verwandten Modulen. Sie können Ihre eigenen Pakete erstellen, indem Sie Ihre Python-Dateien in Verzeichnissen organisieren und die Datei __init__.py verwenden, um den Inhalt des Pakets zu definieren.

my_package/
    __init__.py
    module1.py
    module2.py

In der __init__.py-Datei können Sie angeben, welche Module oder Funktionen verfügbar sein sollen, wenn das Paket importiert wird:

# my_package/__init__.py
from .module1 import function1
from .module2 import function2

Dann können Sie die Funktionen aus dem Paket importieren und verwenden:

import my_package
 
my_package.function1()
my_package.function2()

Datei Ein-/Ausgabe

Python bietet mehrere Funktionen und Methoden zum Lesen aus und Schreiben in Dateien. Der gebräuchlichste Weg, mit Dateien zu arbeiten, ist die Verwendung der open()-Funktion.

# Eine Datei zum Schreiben öffnen
with open("beispiel.txt", "w") as datei:
    datei.write("Hallo, Welt!")
 
# Eine Datei zum Lesen öffnen
with open("beispiel.txt", "r") as datei:
    inhalt = datei.read()
    print(inhalt)  # Ausgabe: Hallo, Welt!

In diesem Beispiel verwenden wir die with-Anweisung, um sicherzustellen, dass die Datei ordnungsgemäß geschlossen wird, wenn wir damit fertig sind. Der Modus "w" öffnet die Datei zum Schreiben und der Modus "r" öffnet die Datei zum Lesen.

Sie können auch Zeilenweise in Dateien schreiben und lesen:

# Zeilen in eine Datei schreiben
zeilen = ["Zeile 1", "Zeile 2", "Zeile 3"]
with open("beispiel.txt", "w") as datei:
    for zeile in zeilen:
        datei.write(zeile + "\n")
 
# Zeilen aus einer Datei lesen
with open("beispiel.txt", "r") as datei:
    for zeile in datei:
        print(zeile.strip())

In diesem Beispiel schreiben wir eine Liste von Zeilen in eine Datei und lesen dann die Zeilen aus der Datei und geben sie aus.

Fehlerbehandlung

Das Fehlerbehandlungsmechanismus von Python ermöglicht es Ihnen, Fehler und unerwartete Situationen in Ihrem Code zu behandeln. Das try-except-Block wird verwendet, um Ausnahmen abzufangen und zu behandeln.

try:
    ergebnis = 10 / 0  # Dies wird einen ZeroDivisionError auslösen
except ZeroDivisionError:
    print("Fehler: Division durch Null")

In diesem Beispiel kann der Code innerhalb des try-Blocks einen ZeroDivisionError auslösen, der dann im except-Block abgefangen und behandelt wird.

Sie können auch mehrere Ausnahmen abfangen und einen generischen Exception-Block bereitstellen:

try:
    num = int(input("Geben Sie eine Zahl ein: "))
    ergebnis = 10 / num
except ValueError:
    print("Fehler: Ungültige Eingabe. Bitte geben Sie eine Zahl ein.")
except ZeroDivisionError:
    print("Fehler: Division durch Null")
except Exception as e:
    print(f"Ein unerwarteter Fehler ist aufgetreten: {e}")

In diesem Beispiel behandeln wir explizit ValueError und ZeroDivisionError Ausnahmen und verwenden einen generischen Exception-Block, um andere unerwartete Fehler abzufangen.

Fazit

In diesem Tutorial haben Sie verschiedene Aspekte der Python-Programmierung kennengelernt, einschließlich Funktionen, Module und Pakete, Datei-Ein-/Ausgabe und Fehlerbehandlung. Diese Konzepte sind wesentlich für den Aufbau komplexerer und robuster Python-Anwendungen. Vergessen Sie nicht, mit den bereitgestellten Code-Snippets zu üben und zu experimentieren, um Ihr Verständnis dieser Themen zu festigen.

MoeNagy Dev