Algorithmen für maschinelles Lernen können kategoriale Variablen nicht verarbeiten. Aber Entscheidungsbäume (DTs) können. Klassifizierungsbäume erfordern auch kein numerisches Ziel. Unten ist eine Darstellung eines Baumes, der eine Untergruppe von kyrillischen Buchstaben in Vokale und Konsonanten einteiliert. Es verwendet keine numerischen Merkmale – es existiert jedoch.

Viele fördern auch die mittlere Zielcodierung (MTE) als clevere Methode, um kategoriale Daten in numerische Kind umzuwandeln-ohne den Merkmalsraum als One-Scorching-Codierung aufzublasen. Ich habe jedoch keine Erwähnung dieser inhärenten Verbindung zwischen MTE und Resolution Tree Logic zu TDs gesehen. Dieser Artikel befasst sich genau mit dieser Lücke durch ein veranschaulichendes Experiment. Insbesondere:

• Ich werde mit einer kurzen Zusammenfassung der Artwork und Weise beginnen, wie Entscheidungsbäume Behandeln Sie kategoriale Merkmale.
• Wir werden sehen, dass dies zu einer rechnerischen Herausforderung für Funktionen mit hoher Kardinalität wird.
• Ich werde demonstrieren, wie die mittlere Zielcodierung auf natürliche Weise als Lösung für dieses Downside auftritt – im Gegensatz zu Beschriftungscodierung.
• Sie können mein Experiment mit dem Code aus reproduzieren Github.

Ein kurzer Hinweis: One-Scorching-Codierung wird oft von Followers der mittleren Zielcodierung ungünstig dargestellt-aber es ist nicht so schlimm, wie sie vermuten lassen. Tatsächlich belegte es in unseren Benchmark -Experimenten häufig den ersten Platz unter den 32 kategorialen Codierungsmethoden, die wir bewertet haben. (1)

Entscheidungsbäume und der Fluch der kategorialen Merkmale

Entscheidungsbaumlernen ist ein rekursiver Algorithmus. Bei jedem rekursiven Schritt iteriert es alle Funktionen und sucht nach dem besten Cut up. Es reicht additionally aus, zu untersuchen, wie eine einzige rekursive Iteration mit einem kategorialen Merkmal umgeht. Wenn Sie sich nicht sicher sind, wie sich diese Operation auf die Konstruktion des vollen Baumes verallgemeinert, schauen Sie sich hier an (2).

Für eine kategoriale Funktion bewertet der Algorithmus alle möglichen Möglichkeiten, die Kategorien in zwei nicht leere Sätze zu unterteilen, und wählt die aus, die die höchste Cut up -Qualität ergibt. Die Qualität wird typischerweise unter Verwendung von Gini -Verunreinigungen für binäre Klassifizierung oder mittlerer quadratischer Fehler für die Regression gemessen – beide sind besser, wenn sie niedriger sind. Siehe ihren Pseudocode unten.

# ----------  Gini impurity criterion  ----------
FUNCTION GiniImpurityForSplit(cut up):
    left, proper = cut up
    complete = dimension(left) + dimension(proper)
    RETURN (dimension(left)/complete)  * GiniOfGroup(left) +
           (dimension(proper)/complete) * GiniOfGroup(proper)

FUNCTION GiniOfGroup(group):
    n = dimension(group)
    IF n == 0: RETURN 0
    ones  = rely(values equal 1 in group)
    zeros = n - ones
    p1 = ones / n
    p0 = zeros / n
    RETURN 1 - (p0² + p1²)

# ----------  Imply-squared-error criterion  ----------
FUNCTION MSECriterionForSplit(cut up):
    left, proper = cut up
    complete = dimension(left) + dimension(proper)
    IF complete == 0: RETURN 0
    RETURN (dimension(left)/complete)  * MSEOfGroup(left) +
           (dimension(proper)/complete) * MSEOfGroup(proper)

FUNCTION MSEOfGroup(group):
    n = dimension(group)
    IF n == 0: RETURN 0
    μ = imply(Worth column of group)
    RETURN sum( (v − μ)² for every v in group ) / n

Nehmen wir an, die Funktion hat eine Kardinalität okay. Jede Kategorie kann zu einer der beiden Sätze gehören, die 2 gebenᵏ Gesamtkombinationen. Ohne die beiden trivialen Fälle, in denen einer der Units leer ist, werden wir 2 übrig bleibenᵏ–2 Machbare Spaltungen. Beachten Sie als nächstes, dass wir uns nicht um die Reihenfolge der Units kümmern – Spaltungen wie {{A, B}, {C}} und {{C}, {a, b}} sind äquivalent. Dies senkt die Anzahl der eindeutigen Kombinationen in zwei Hälften, was zu einer endgültigen Anzahl von (2) führtᵏ–2)/2 Iterationen. Für unser oben genannter Spielzeugbeispiel mit Ok = 5 Kyrillische Buchstaben, diese Zahl ist 15. Aber wann Ok = 20Es Luftballons auf 524.287 Kombinationen – genug, um das DT -Coaching erheblich zu verlangsamen.

Die mittlere Zielcodierung löst das Effizienzproblem

Was wäre, wenn man den Suchraum von (2) reduzieren könnteᵏ–2)/2 zu etwas überschaubarer – ohne die optimale Spaltung zu verlieren? Es stellt sich heraus, dass dies in der Tat möglich ist. Man kann theoretisch zeigen, dass die mittlere Zielcodierung diese Reduzierung ermöglicht (3). Wenn die Kategorien in der Reihenfolge ihrer MTE -Werte angeordnet sind und nur aufteilt, die diese Reihenfolge respektieren, werden die optimalen Cut up – gemäß Gini -Verunreinigung für die Klassifizierung oder mittlerer quadratischer Fehler für die Regression – unter ihnen sein. Es gibt genau Ok-1 Solche Spaltungen, eine dramatische Reduktion im Vergleich zu (2ᵏ–2)/2. Der Pseudocode für MTE ist unten.

# ----------  Imply-target encoding ----------
FUNCTION MeanTargetEncode(desk):
    category_means = common(Worth) for every Class in desk      # Class → imply(Worth)
    encoded_column = lookup(desk.Class, category_means)         # exchange label with imply
    RETURN encoded_column

Experiment

Ich werde die theoretischen Ableitungen, die die oben genannten Ansprüche stützen, nicht wiederholen. Stattdessen habe ich ein Experiment entworfen, um sie empirisch zu validieren und ein Gefühl für die Effizienzgewinne zu erhalten, die von MTE gegenüber der nativen Partitionierung erzielt wurden, die alle möglichen Spaltungen umfassend iteriert. Im Folgenden erkläre ich den Datengenerierungsprozess und den Experiment -Setup.

Daten

Um synthetische Daten für das Experiment zu generieren, habe ich eine einfache Funktion verwendet, die einen Zwei-Spalt-Datensatz erstellt. Die erste Spalte enthält N unterschiedliche kategoriale Ebenen, jeweils wiederholt M mal, was zu insgesamt führt N × m Reihen. Die zweite Spalte repräsentiert die Zielvariable und kann je nach Eingabeparameter entweder binär oder kontinuierlich sein. Unten finden Sie den Pseudocode für diese Funktion.

# ----------  Artificial-dataset generator ----------
FUNCTION GenerateData(num_categories, rows_per_cat, target_type='binary'):
    total_rows = num_categories * rows_per_cat
    classes = ('Category_' + i for i in 1..num_categories)
    category_col = repeat_each(classes, rows_per_cat)

    IF target_type == 'steady':
        target_col = random_floats(0, 1, total_rows)
    ELSE:
        target_col = random_ints(0, 1, total_rows)

    RETURN DataFrame{ 'Class': category_col,
                      'Worth'   : target_col }

Experiment -Setup

Der experiment Die Funktion übernimmt eine Liste von Kardinalitäten und ein Spaltkriterium – entweder Gini -Verunreinigungen oder mittlerer quadratischer Fehler, abhängig vom Zieltyp. Für jede kategoriale Function-Kardinalität in der Liste generiert es 100 Datensätze und vergleicht zwei Strategien: eine erschöpfende Bewertung aller möglichen Kategorienaufteilungen und der eingeschränkten, mTE-informierten Bestellung. Es misst die Laufzeit jeder Methode und prüft, ob beide Ansätze den gleichen optimalen Cut up -Rating erzeugen. Die Funktion gibt die Anzahl der Übereinstimmungsfälle zusammen mit durchschnittlichen Laufzeiten zurück. Der Pseudocode ist unten angegeben.

# ----------  Cut up comparability experiment ----------
FUNCTION RunExperiment(list_num_categories, splitting_criterion):
    outcomes = ()

    FOR okay IN list_num_categories:
        times_all = ()
        times_ord = ()

        REPEAT 100 instances:
            df = GenerateDataset(okay, 100)

            t0 = now()
            s_all = MinScore(df, AllSplits, splitting_criterion)
            t1 = now()

            t2 = now()
            s_ord = MinScore(df, MTEOrderedSplits, splitting_criterion)
            t3 = now()

            times_all.append(t1 - t0)
            times_ord.append(t3 - t2)

            IF spherical(s_all,10) != spherical(s_ord,10):
                PRINT "Discrepancy at okay=", okay

        outcomes.append({
            'okay': okay,
            'avg_time_all': imply(times_all),
            'avg_time_ord': imply(times_ord)
        })

    RETURN DataFrame(outcomes)

Ergebnisse

Sie können mein Wort dafür nehmen oder das Experiment wiederholen (Github) – aber die optimalen Cut up -Scores beider Ansätze stimmten immer überein, genau wie die Theorie vorhersagt. Die folgende Abbildung zeigt die Zeit, die für die Bewertung von Splits als Funktion der Anzahl der Kategorien erforderlich ist. Die vertikale Achse befindet sich auf einer logarithmischen Skala. Die Linie, die eine ausführliche Bewertung darstellt, erscheint in diesen Koordinaten linear, was bedeutet, dass die Laufzeit exponentiell mit der Anzahl der Kategorien wächst – was die zuvor diskutierte theoretische Komplexität bestätigt. Bereits in 12 Kategorien (in einem Datensatz mit 1.200 Zeilen) dauert die Überprüfung aller möglichen Spaltungen etwa eine Sekunde-drei Größenordnungen langsamer als der MTE-basierte Ansatz, der den gleichen optimalen Cut up ergibt.

Abschluss

Entscheidungsbäume können kategoriale Daten nativ verarbeiten, aber diese Fähigkeit erfolgt zu einer Rechenkosten, wenn die Kategorie zählt. Die mittlere Zielcodierung bietet eine prinzipielle Abkürzung, wodurch die Anzahl der Kandidatenaufteilungen drastisch verringert wird, ohne das Ergebnis zu beeinträchtigen. Unser Experiment bestätigt die Theorie: MTE-basierte Order findet den gleichen optimalen Cut up, aber exponentiell schneller.

Zum Zeitpunkt des Schreibens, scikit-learn unterstützt kategoriale Merkmale nicht direkt. Was denkst du additionally – wenn Sie die Daten mit MTE vorab zusammenarbeiten, entspricht der resultierende Entscheidungsbaum einem, das von einem Lernenden erstellt wurde, der kategoriale Merkmale nativ übernimmt?

Referenzen

(1) Ein Benchmark und eine Taxonomie kategorischer Encoder. Auf Knowledge Science. https://towardsdatascience.com/a-benchmark-and-taxonomy-of-categorical-coder-9b7a0dc47a8c/

(2) Bergbauregeln aus Daten. Auf Knowledge Science. https://towardsdatascience.com/mining-rules-from-data

(3) Hastie, Trevor, Tibshirani, Robert und Friedman, Jerome. Die Elemente des statistischen Lernens: Knowledge Mining, Inferenz und Vorhersage. Vol. 2. New York: Springer, 2009.

Bild vom Autor

Entscheidungsbäume unterteilen schwierige Entscheidungen in einfache, leicht nachvollziehbare Phasen und funktionieren daher wie das menschliche Gehirn.

In der Datenwissenschaft werden diese leistungsstarken Instrumente umfassend eingesetzt, um die Datenanalyse und die Entscheidungsfindung zu unterstützen.

In diesem Artikel gehe ich auf die Funktionsweise von Entscheidungsbäumen ein, gebe Beispiele aus der Praxis und einige Tipps zu ihrer Verbesserung.

Struktur von Entscheidungsbäumen

Im Grunde sind Entscheidungsbäume einfache und klare Werkzeuge. Sie zerlegen schwierige Optionen in einfachere, aufeinander folgende Auswahlmöglichkeiten und spiegeln somit die menschliche Entscheidungsfindung wider. Lassen Sie uns nun die Hauptelemente untersuchen, aus denen ein Entscheidungsbaum besteht.

Knoten, Zweige und Blätter

Drei grundlegende Komponenten definieren einen Entscheidungsbaum: Blätter, Zweige und Knoten. Jede dieser Komponenten ist für den Entscheidungsprozess absolut wichtig.

• Knoten: Es handelt sich um Entscheidungspunkte, an denen der Baum abhängig von den Eingabedaten entscheidet. Bei der Darstellung aller Daten ist der Wurzelknoten der Ausgangspunkt.

• Filialen: Sie beziehen sich auf das Ergebnis einer Entscheidung und verknüpfen Knoten. Jeder Zweig entspricht einem möglichen Ergebnis oder Wert eines Entscheidungsknotens.
• Blätter: Die Enden des Entscheidungsbaums sind Blätter, manchmal auch Blattknoten genannt. Jeder Blattknoten bietet eine bestimmte Konsequenz oder Bezeichnung; sie spiegeln die letzte Wahl oder Klassifizierung wider.

Konzeptionelles Beispiel

Angenommen, Sie entscheiden je nach Temperatur, ob Sie nach draußen gehen. „Regnet es?“, würde der Stammknoten fragen. Wenn ja, finden Sie möglicherweise einen Zweig, der in Richtung „Nehmen Sie einen Regenschirm mit“ geht. Dies sollte nicht der Fall sein; ein anderer Zweig könnte lauten: „Tragen Sie eine Sonnenbrille.“

Aufgrund dieser Strukturen sind Entscheidungsbäume leicht zu interpretieren und zu visualisieren und erfreuen sich daher in zahlreichen Bereichen großer Beliebtheit.

Beispiel aus der Praxis: Das Abenteuer der Kreditgenehmigung

Stellen Sie sich vor: Sie sind ein Zauberer bei der Gringotts Financial institution und entscheiden, wer einen Kredit für seinen neuen Besen bekommt.

• Stammknoten: „Ist ihr Kredit-Rating magisch?“
• Falls ja → Weiter zu „Genehmigen Sie schneller, als Sie Quidditch sagen können!“
• Wenn nein → Weiter mit „Überprüfen Sie ihre Goldreserven der Kobolde.“
  • Wenn hoch →: „Genehmigen Sie, aber behalten Sie sie im Auge.“
  • Wenn niedrig → „Schneller ablehnen als ein Nimbus 2000.“

import pandas as pd
from sklearn.tree import DecisionTreeClassifier
from sklearn import tree
import matplotlib.pyplot as plt

information = {
    'Credit_Score': (700, 650, 600, 580, 720),
    'Earnings': (50000, 45000, 40000, 38000, 52000),
    'Accepted': ('Sure', 'No', 'No', 'No', 'Sure')
}

df = pd.DataFrame(information)

X = df(('Credit_Score', 'Earnings'))
y = df('Accepted')

clf = DecisionTreeClassifier()
clf = clf.match(X, y)

plt.determine(figsize=(10, 8))
tree.plot_tree(clf, feature_names=('Credit_Score', 'Earnings'), class_names=('No', 'Sure'), stuffed=True)
plt.present()

Hier ist die Ausgabe.

Wenn du diesen Zauber ausführst, siehst du einen Baum erscheinen! Er ist wie die Karte des Rumtreibers mit den Kreditgenehmigungen:

• Der Wurzelknoten teilt sich auf Credit_Score
• Wenn es ≤ 675 ist, wagen wir uns nach hyperlinks
• Wenn es > 675 ist, reisen wir direkt
• Die Blätter zeigen unsere endgültigen Entscheidungen: „Ja“ für genehmigt, „Nein“ für abgelehnt

Voilà! Sie haben gerade eine Kristallkugel zur Entscheidungsfindung geschaffen!

Gedankenverdreher: Wenn Ihr Leben ein Entscheidungsbaum wäre, wie würde die Frage am Stammknoten lauten? „Habe ich heute Morgen Kaffee getrunken?“ könnte zu einigen interessanten Verzweigungen führen!

Entscheidungsbäume: Hinter den Zweigen

Entscheidungsbäume funktionieren ähnlich wie Flussdiagramme oder Baumstrukturen und bestehen aus einer Abfolge von Entscheidungspunkten. Sie beginnen damit, einen Datensatz in kleinere Teile aufzuteilen, und erstellen dann einen entsprechenden Entscheidungsbaum. Wir sollten uns einmal ansehen, wie diese Bäume mit der Aufteilung der Daten und unterschiedlichen Variablen umgehen.

Aufteilungskriterien: Gini-Unreinheit und Informationsgewinn

Das Hauptziel beim Erstellen eines Entscheidungsbaums besteht darin, die beste Qualität für die Aufteilung der Daten zu wählen. Dieses Verfahren lässt sich anhand der Kriterien Informationsgewinn und Gini-Unreinheit bestimmen.

• Gini-Unreinheit: Stellen Sie sich vor, Sie wären mitten in einem Ratespiel. Wie oft würden Sie einen Fehler machen, wenn Sie eine Bezeichnung zufällig auswählen würden? Das ist das Maß für die Gini-Unreinheit. Wir können bessere Vermutungen anstellen und einen glücklicheren Baum mit einem niedrigeren Gini-Koeffizienten haben.
• Informationsgewinn: Vergleichbar ist dies mit dem „Aha!“-Second in einem Krimi. Daran lässt sich messen, wie sehr ein Hinweis (Attribut) zur Lösung des Falles beiträgt. Ein größeres „Aha!“ bedeutet mehr Gewinn, was wiederum einen ekstatischen Baum bedeutet!

Um vorherzusagen, ob ein Kunde ein Produkt aus Ihrem Datensatz kaufen würde, können Sie mit grundlegenden demografischen Informationen wie Alter, Einkommen und Kaufhistorie beginnen. Der Ansatz berücksichtigt all diese Informationen und findet die Informationen, die die Käufer von den anderen unterscheiden.

Umgang mit kontinuierlichen und kategorialen Daten

Es gibt keine Informationen, die unsere Baumdetektive nicht untersuchen können.

Für leicht veränderbare Merkmale wie Alter oder Einkommen stellt der Baum eine Radarfalle auf. „Jeder über 30, hier entlang!“

Bei kategorialen Daten wie Geschlecht oder Produkttyp handelt es sich eher um eine Aufstellung. „Smartphones stehen hyperlinks, Laptops rechts!“

Ungelöster Fall aus der realen Welt: Der Kundenkauf-Prognosetool

Um besser zu verstehen, wie Entscheidungsbäume funktionieren, sehen wir uns ein Beispiel aus dem echten Leben an: Anhand des Alters und des Einkommens eines Kunden wird erraten, ob er ein Produkt kaufen wird.

Um zu erraten, was die Leute kaufen werden, erstellen wir eine einfache Sammlung und einen Entscheidungsbaum.

Eine Beschreibung des Codes

• Wir importieren Bibliotheken wie Pandas, um mit den Daten zu arbeiten, DecisionTreeClassifier von scikit-learn, um den Baum zu erstellen, und Matplotlib, um die Ergebnisse anzuzeigen.
• Datensatz erstellen: Alter, Einkommen und Kaufstatus werden verwendet, um einen Beispieldatensatz zu erstellen.
• Bereiten Sie Funktionen und Ziele vor: Die Zielvariable (Gekauft) und die Funktionen (Alter, Einkommen) werden eingerichtet.
• Trainieren des Modells: Die Informationen werden verwendet, um den Entscheidungsbaum-Klassifikator einzurichten und zu trainieren.
• Den Baum ansehen: Zum Schluss zeichnen wir den Entscheidungsbaum, damit wir sehen können, wie Entscheidungen getroffen werden.

Hier ist der Code.

import pandas as pd
from sklearn.tree import DecisionTreeClassifier
from sklearn import tree
import matplotlib.pyplot as plt

information = {
    'Age': (25, 45, 35, 50, 23),
    'Earnings': (50000, 100000, 75000, 120000, 60000),
    'Bought': ('No', 'Sure', 'No', 'Sure', 'No')
}

df = pd.DataFrame(information)

X = df(('Age', 'Earnings'))
y = df('Bought')

clf = DecisionTreeClassifier()
clf = clf.match(X, y)

plt.determine(figsize=(10, 8))
tree.plot_tree(clf, feature_names=('Age', 'Earnings'), class_names=('No', 'Sure'), stuffed=True)
plt.present()

Hier ist die Ausgabe.

Der endgültige Entscheidungsbaum zeigt, wie sich der Baum nach Alter und Einkommen aufteilt, um herauszufinden, ob ein Kunde wahrscheinlich ein Produkt kaufen wird. Jeder Knoten ist ein Entscheidungspunkt und die Zweige zeigen unterschiedliche Ergebnisse. Die endgültige Entscheidung wird durch die Blattknoten angezeigt.

Sehen wir uns nun an, wie Interviews in der realen Welt eingesetzt werden können!

Anwendungen in der Praxis

Dieses Projekt ist als Hausaufgabe für Meta-(Fb-)Datenwissenschaftler gedacht. Ziel ist es, einen Klassifizierungsalgorithmus zu entwickeln, der vorhersagt, ob ein Movie auf Rotten Tomatoes als „Rotten“, „Contemporary“ oder „Licensed Contemporary“ gekennzeichnet ist.

Hier ist der Hyperlink zu diesem Projekt: https://platform.stratascratch.com/data-projects/rotten-tomatoes-movies-rating-prediction

Lassen Sie uns die Lösung nun in codierbare Schritte aufteilen.

Schritt-für-Schritt-Lösung

1. Datenaufbereitung: Wir werden die beiden Datensätze auf der Hyperlink zu faulen Tomaten Spalte. Dadurch erhalten wir einen umfassenden Datensatz mit Filminformationen und Kritiken.
2. Funktionsauswahl und -entwicklung: Wir wählen relevante Merkmale aus und führen die erforderlichen Transformationen durch. Dazu gehört die Konvertierung kategorialer Variablen in numerische, die Behandlung fehlender Werte und die Normalisierung der Merkmalswerte.
3. Modelltraining: Wir werden einen Entscheidungsbaum-Klassifikator anhand des verarbeiteten Datensatzes trainieren und eine Kreuzvalidierung verwenden, um die robuste Leistung des Modells zu bewerten.
4. Auswertung: Abschließend bewerten wir die Leistung des Modells anhand von Kennzahlen wie Genauigkeit, Präzision, Rückruf und F1-Rating.

Hier ist der Code.

import pandas as pd
from sklearn.model_selection import train_test_split, cross_val_score
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import classification_report
from sklearn.preprocessing import StandardScaler

movies_df = pd.read_csv('rotten_tomatoes_movies.csv')
reviews_df = pd.read_csv('rotten_tomatoes_critic_reviews_50k.csv')

merged_df = pd.merge(movies_df, reviews_df, on='rotten_tomatoes_link')

options = ('content_rating', 'genres', 'administrators', 'runtime', 'tomatometer_rating', 'audience_rating')
goal="tomatometer_status"

merged_df('content_rating') = merged_df('content_rating').astype('class').cat.codes
merged_df('genres') = merged_df('genres').astype('class').cat.codes
merged_df('administrators') = merged_df('administrators').astype('class').cat.codes

merged_df = merged_df.dropna(subset=options + (goal))

X = merged_df(options)
y = merged_df(goal).astype('class').cat.codes

scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

X_train, X_test, y_train, y_test = train_test_split(X_scaled, y, test_size=0.3, random_state=42)

clf = DecisionTreeClassifier(max_depth=10, min_samples_split=10, min_samples_leaf=5)
scores = cross_val_score(clf, X_train, y_train, cv=5)
print("Cross-validation scores:", scores)
print("Common cross-validation rating:", scores.imply())

clf.match(X_train, y_train)

y_pred = clf.predict(X_test)

classification_report_output = classification_report(y_test, y_pred, target_names=('Rotten', 'Contemporary', 'Licensed-Contemporary'))
print(classification_report_output)

Hier ist die Ausgabe.

Das Modell weist eine hohe Genauigkeit und F1-Wertungen in allen Klassen auf, was auf eine gute Leistung schließen lässt. Sehen wir uns die wichtigsten Erkenntnisse an.

Die wichtigsten Erkenntnisse

1. Die Auswahl der Merkmale ist für die Leistung des Modells von entscheidender Bedeutung. Die Laufzeit und Bewertungen der Regisseure bei der Bewertung von Inhaltsgenres erwiesen sich als wertvolle Prädiktoren.
2. Ein Entscheidungsbaum-Klassifikator erfasst effektiv komplexe Beziehungen in Filmdaten.
3. Durch Kreuzvalidierung wird die Modellzuverlässigkeit über verschiedene Datenteilmengen hinweg sichergestellt.
4. Eine hohe Leistung in der Klasse „Licensed-Contemporary“ rechtfertigt weitere Untersuchungen hinsichtlich eines möglichen Ungleichgewichts in den Klassen.
5. Das Modell ist vielversprechend für die Anwendung in der Praxis bei der Vorhersage von Filmbewertungen und der Verbesserung des Benutzererlebnisses auf Plattformen wie Rotten Tomatoes.

Entscheidungsbäume verbessern: So wird aus Ihrem Setzling eine mächtige Eiche

Sie haben additionally Ihren ersten Entscheidungsbaum erstellt. Beeindruckend! Aber warum hier aufhören? Lassen Sie uns diesen Setzling in einen Waldriesen verwandeln, der sogar Groot neidisch machen würde. Bereit, Ihren Baum aufzupeppen? Dann legen wir los!

Schnitttechniken

Pruning ist eine Methode, mit der die Größe eines Entscheidungsbaums reduziert wird, indem Teile eliminiert werden, die nur eine minimale Fähigkeit zur Vorhersage von Zielvariablen haben. Dies hilft insbesondere dabei, Überanpassung zu reduzieren.

• Vorschnitt: Dies wird oft als frühzeitiges Stoppen bezeichnet und bedeutet, dass das Wachstum des Baums sofort gestoppt wird. Vor dem Coaching werden dem Modell Parameter angegeben, einschließlich der maximalen Tiefe (maximale Tiefe), Mindestanzahl an Stichproben, die zum Teilen eines Knotens erforderlich sind (min_samples_split) und die Mindestanzahl an Stichproben, die an einem Blattknoten erforderlich sind (min_samples_leaf). Dadurch wird verhindert, dass der Baum zu kompliziert wird.
• Nachschnitt: Mit dieser Methode wird der Baum bis zur maximalen Tiefe erweitert und Knoten entfernt, die nicht viel Leistung bieten. Obwohl das Vorbeschneiden rechnerisch aufwändiger ist als das Vorbeschneiden, kann das Nachbeschneiden erfolgreicher sein.

Ensemble-Methoden

Ensembletechniken kombinieren mehrere Modelle, um eine Leistung zu erzielen, die über der eines einzelnen Modells liegt. Zwei Hauptformen von Ensembletechniken, die mit Entscheidungsbäumen angewendet werden, sind Bagging und Boosting.

• Bagging (Bootstrap-Aggregation): Diese Methode trainiert mehrere Entscheidungsbäume anhand mehrerer Teilmengen der Daten (erzeugt durch Stichprobenziehung mit Zurücklegen) und berechnet dann den Durchschnitt ihrer Vorhersagen. Eine häufig verwendete Bagging-Technik ist Random Forest. Sie verringert die Varianz und hilft bei der Vermeidung von Überanpassung. Schauen Sie sich „Entscheidungsbaum und Random-Forest-Algorithmus“ um ausführlich auf alles einzugehen, was mit dem Entscheidungsbaum-Algorithmus und seiner Erweiterung „Random-Forest-Algorithmus“ zu tun hat.
• Verstärkung: Boosting erstellt nacheinander Bäume, wobei jeder versucht, die Fehler des nächsten zu beheben. Boosting-Techniken gibt es in Algorithmen wie AdaBoost und Gradient Boosting in Hülle und Fülle. Durch die Betonung schwer vorhersagbarer Beispiele liefern diese Algorithmen manchmal genauere Modelle.

Hyperparameter-Tuning

Hyperparameter-Tuning ist der Prozess der Bestimmung des optimalen Hyperparameter-Units für ein Entscheidungsbaummodell, um dessen Leistung zu steigern. Dies kann mit Methoden wie Grid Search oder Random Search erreicht werden, bei denen mehrere Kombinationen von Hyperparametern bewertet werden, um die beste Konfiguration zu ermitteln.

Abschluss

In diesem Artikel haben wir die Struktur, den Arbeitsmechanismus, reale Anwendungen und Methoden zur Verbesserung der Entscheidungsbaumleistung besprochen.

Das Üben von Entscheidungsbäumen ist entscheidend, um ihre Verwendung zu beherrschen und ihre Nuancen zu verstehen. Die Arbeit an realen Datenprojekten kann ebenfalls wertvolle Erfahrungen liefern und die Problemlösungskompetenz verbessern.

Nate Rosidi ist Datenwissenschaftler und arbeitet in der Produktstrategie. Er ist außerdem außerordentlicher Professor für Analytik und Gründer von StrataScratch, einer Plattform, die Datenwissenschaftlern mit echten Interviewfragen von High-Unternehmen bei der Vorbereitung auf ihre Vorstellungsgespräche hilft. Nate schreibt über die neuesten Tendencies auf dem Arbeitsmarkt, gibt Interviewtipps, teilt Datenwissenschaftsprojekte und deckt alles ab, was mit SQL zu tun hat.