Machen Sie diese Fehler bei der Klassifizierungsmodellierung?

Einführung

Die Bewertung eines maschinellen Lernmodells ist nicht nur der letzte Schritt, sondern der Grundstein für den Erfolg. Stellen Sie sich vor, Sie erstellen ein hochmodernes Modell, das mit hoher Genauigkeit glänzt, nur um dann festzustellen, dass es unter dem Druck der realen Welt zusammenbricht. Bei der Bewertung geht es um mehr als das Abhaken von Kennzahlen; es geht darum, sicherzustellen, dass Ihr Modell in der Praxis konstant funktioniert. In diesem Artikel tauchen wir in die üblichen Fallstricke ein, die selbst die vielversprechendsten Klassifizierungsmodelle zum Scheitern bringen können, und enthüllen die Finest Practices, mit denen Sie Ihr Modell von intestine zu außergewöhnlich machen können. Lassen Sie uns Ihre Klassifizierungsmodellierungsaufgaben in zuverlässige, effektive Lösungen verwandeln.

Überblick

• Erstellen eines Klassifizierungsmodells: Erstellen Sie mit Schritt-für-Schritt-Anleitung ein solides Klassifizierungsmodell.
• Häufige Fehler erkennen: Erkennen und vermeiden Sie häufige Fehler bei der Klassifikationsmodellierung.
• Overfitting verstehen: Verstehen Sie Overfitting und erfahren Sie, wie Sie es in Ihren Modellen verhindern können.
• Verbessern Sie Ihre Fähigkeiten im Modellbau: Verbessern Sie Ihre Fähigkeiten im Modellerstellung mit Finest Practices und fortgeschrittenen Techniken.

Klassifizierungsmodellierung: Ein Überblick

Im Klassifizierungsproblem versuchen wir, ein Modell zu erstellen, das die Beschriftungen der Zielvariablen unter Verwendung unabhängiger Variablen vorhersagt. Da wir mit beschrifteten Zieldaten arbeiten, benötigen wir überwachte maschinelle Lernalgorithmen wie logistische Regression, SVM, Entscheidungsbaum usw. Wir werden uns auch ansehen Neuronale Netzwerkmodelle zur Lösung des Klassifizierungsproblems, zur Identifizierung typischer Fehler und zur Ermittlung, wie diese vermieden werden können.

Erstellen eines grundlegenden Klassifizierungsmodells

Wir demonstrieren die Erstellung eines grundlegenden Klassifizierungsmodells mit dem Date-Fruit-Datensatz von Kaggle. Über den Datensatz: Die Zielvariable besteht aus sieben Dattelsorten: Barhee, Deglet Nour, Sukkary, Rotab Mozafati, Ruthana, Safawi und Sagai. Der Datensatz besteht aus 898 Bildern von sieben verschiedenen Dattelfruchtsorten und 34 Merkmale wurden durch Bildverarbeitungstechniken extrahiert. Ziel ist es, diese Früchte anhand ihrer Eigenschaften zu klassifizieren.

1. Datenaufbereitung

import pandas as pd

   from sklearn.model_selection import train_test_split

   from sklearn.preprocessing import StandardScaler

   # Load the dataset

   information = pd.read_excel('/content material/Date_Fruit_Datasets.xlsx')

   # Splitting the info into options and goal

   X = information.drop('Class', axis=1)

   y = information('Class')

   # Splitting the dataset into coaching and testing units

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

   # Characteristic scaling

   scaler = StandardScaler()

   X_train = scaler.fit_transform(X_train)

   X_test = scaler.remodel(X_test)

2. Logistische Regression

from sklearn.linear_model import LogisticRegression

   from sklearn.metrics import accuracy_score

   # Logistic Regression Mannequin

   log_reg = LogisticRegression()

   log_reg.match(X_train, y_train)

   # Predictions and Analysis

   y_train_pred = log_reg.predict(X_train)

   y_test_pred = log_reg.predict(X_test)

   # Accuracy

   train_acc = accuracy_score(y_train, y_train_pred)

   test_acc = accuracy_score(y_test, y_test_pred)

   print(f'Logistic Regression - Prepare Accuracy: {train_acc}, Check Accuracy: {test_acc}')

Ergebnisse:

- Logistic Regression - Prepare Accuracy: 0.9538
- Check Accuracy: 0.9222

Lesen Sie auch: Eine Einführung in die logistische Regression

3. Assist Vector Machine (SVM)

from sklearn.svm import SVC

   from sklearn.metrics import accuracy_score

   # SVM

   svm = SVC(kernel="linear", chance=True)

   svm.match(X_train, y_train)

   # Predictions and Analysis

   y_train_pred = svm.predict(X_train)

   y_test_pred = svm.predict(X_test)

   train_accuracy = accuracy_score(y_train, y_train_pred)

   test_accuracy = accuracy_score(y_test, y_test_pred)

   print(f"SVM - Prepare Accuracy: {train_accuracy}, Check Accuracy: {test_accuracy}")

Ergebnisse:

- SVM - Prepare Accuracy: 0.9602
- Check Accuracy: 0.9074

Lesen Sie auch: Leitfaden zum Assist Vector Machine (SVM)-Algorithmus

4. Entscheidungsbaum

from sklearn.tree import DecisionTreeClassifier

   from sklearn.metrics import accuracy_score

   # Resolution Tree

   tree = DecisionTreeClassifier(random_state=42)

   tree.match(X_train, y_train)

   # Predictions and Analysis

   y_train_pred = tree.predict(X_train)

   y_test_pred = tree.predict(X_test)

   train_accuracy = accuracy_score(y_train, y_train_pred)

   test_accuracy = accuracy_score(y_test, y_test_pred)

   print(f"Resolution Tree - Prepare Accuracy: {train_accuracy}, Check Accuracy: {test_accuracy}")

Ergebnisse:

- Resolution Tree - Prepare Accuracy: 1.0000
- Check Accuracy: 0.8222

5. Neuronale Netze mit TensorFlow

import numpy as np

   from sklearn.preprocessing import LabelEncoder, StandardScaler

   from sklearn.model_selection import train_test_split

   from tensorflow.keras import fashions, layers

   from tensorflow.keras.callbacks import EarlyStopping, ModelCheckpoint

   # Label encode the goal courses

   label_encoder = LabelEncoder()

   y_encoded = label_encoder.fit_transform(y)

   # Prepare-test cut up

   X_train, X_test, y_train, y_test = train_test_split(X, y_encoded, test_size=0.2, random_state=42)

   # Characteristic scaling

   scaler = StandardScaler()

   X_train = scaler.fit_transform(X_train)

   X_test = scaler.remodel(X_test)

   # Neural Community

   mannequin = fashions.Sequential((

     layers.Dense(64, activation='relu', input_shape=(X_train.form(1),)),

     layers.Dense(32, activation='relu'),

     layers.Dense(len(np.distinctive(y_encoded)), activation='softmax')  # Guarantee output layer dimension matches variety of courses

   ))

   mannequin.compile(optimizer="adam", loss="sparse_categorical_crossentropy", metrics=('accuracy'))

   # Callbacks

   early_stopping = EarlyStopping(monitor="val_loss", persistence=10, restore_best_weights=True)

   model_checkpoint = ModelCheckpoint('best_model.keras', monitor="val_loss", save_best_only=True)

   # Prepare the mannequin

   historical past = mannequin.match(X_train, y_train, epochs=100, batch_size=32, validation_data=(X_test, y_test),

                      callbacks=(early_stopping, model_checkpoint), verbose=1)

   # Consider the mannequin

   train_loss, train_accuracy = mannequin.consider(X_train, y_train, verbose=0)

   test_loss, test_accuracy = mannequin.consider(X_test, y_test, verbose=0)

   print(f"Neural Community - Prepare Accuracy: {train_accuracy}, Check Accuracy: {test_accuracy}")

Ergebnisse:

- Neural Community - Prepare Accuracy: 0.9234
- Check Accuracy: 0.9278

Lesen Sie auch: Erstellen Sie Ihr neuronales Netzwerk mit Tensorflow

Die Fehler identifizieren

Klassifizierungsmodelle können auf verschiedene Herausforderungen stoßen, die ihre Wirksamkeit beeinträchtigen können. Um zuverlässige Modelle zu erstellen, ist es wichtig, diese Probleme zu erkennen und anzugehen. Im Folgenden sind einige wichtige Aspekte aufgeführt, die zu berücksichtigen sind:

1. Überanpassung und Unteranpassung:
   • Kreuzvalidierung: Vermeiden Sie es, sich ausschließlich auf eine einzige Trainings-Check-Aufteilung zu verlassen. Nutzen Sie die k-fache Kreuzvalidierung, um die Leistung Ihres Modells besser zu beurteilen, indem Sie es an verschiedenen Datensegmenten testen.
   • Regularisierung: Bei hochkomplexen Modellen kann es zu Überanpassungen kommen, da sie Rauschen in den Daten enthalten. Um die Komplexität zu bestrafen, sollten Regularisierungsmethoden wie Pruning oder Regularisierung eingesetzt werden.
   • Optimierung der Hyperparameter: Untersuchen und optimieren Sie Hyperparameter gründlich (z. B. durch Raster- oder Zufallssuche), um Verzerrungen und Varianz auszugleichen.
2. Ensemble-Techniken:
   • Modellaggregation: Ensemblemethoden wie Random Forests oder Gradient Boosting kombinieren Vorhersagen aus mehreren Modellen, was häufig zu einer verbesserten Generalisierung führt. Diese Techniken können komplexe Muster in den Daten erfassen und gleichzeitig das Risiko einer Überanpassung verringern, indem sie einzelne Modellfehler ausgleichen.
3. Klassenungleichgewicht:
   • Unausgewogene Klassen: In vielen Fällen ist eine Klasse weniger zahlreich als andere, was zu verzerrten Vorhersagen führt. Je nach Drawback müssen Methoden wie Oversampling, Undersampling oder SMOTE verwendet werden.
4. Datenleck:
   • Unbeabsichtigtes Leck: Datenlecks treten auf, wenn Informationen von außerhalb des Trainingssatzes das Modell beeinflussen und zu überhöhten Leistungskennzahlen führen. Es ist entscheidend sicherzustellen, dass die Testdaten während des Trainings völlig unsichtbar bleiben und dass aus der Zielvariable abgeleitete Merkmale mit Sorgfalt verwaltet werden.

Beispiel einer verbesserten logistischen Regression mithilfe der Grid-Suche

from sklearn.model_selection import GridSearchCV

   # Implementing Grid Seek for Logistic Regression

   param_grid = {'C': (0.1, 1, 10, 100), 'solver': ('lbfgs')}

   grid_search = GridSearchCV(LogisticRegression(multi_class="multinomial", max_iter=1000), param_grid, cv=5)

   grid_search.match(X_train, y_train)

   # Finest mannequin

   best_model = grid_search.best_estimator_

   # Consider on check set

   test_accuracy = best_model.rating(X_test, y_test)

   print(f"Finest Logistic Regression - Check Accuracy: {test_accuracy}")

Ergebnisse:

- Finest Logistic Regression - Check Accuracy: 0.9611

Neuronale Netze mit TensorFlow

Konzentrieren wir uns auf die Verbesserung unseres bisherigen neuronalen Netzwerkmodells und legen dabei den Schwerpunkt auf Techniken zur Minimierung von Überanpassung und Verbesserung der Generalisierung.

Frühzeitiges Stoppen und Modell-Checkpointing

Durch frühzeitiges Stoppen wird das Coaching abgebrochen, wenn die Validierungsleistung des Modells ein Plateau erreicht. Dadurch wird eine Überanpassung verhindert, indem übermäßiges Lernen aus Trainingsdatenrauschen vermieden wird.

Durch Mannequin Checkpointing wird das Modell gespeichert, das während des gesamten Trainings im Validierungssatz die beste Leistung zeigt. Dadurch wird sichergestellt, dass die optimale Modellversion erhalten bleibt, auch wenn das nachfolgende Coaching zu einer Überanpassung führt.

import numpy as np

from sklearn.preprocessing import LabelEncoder, StandardScaler

from sklearn.model_selection import train_test_split

from tensorflow.keras import fashions, layers

from tensorflow.keras.callbacks import EarlyStopping, ModelCheckpoint

# Label encode the goal courses

label_encoder = LabelEncoder()

y_encoded = label_encoder.fit_transform(y)

# Prepare-test cut up

X_train, X_test, y_train, y_test = train_test_split(X, y_encoded, test_size=0.2, random_state=42)

# Characteristic scaling

scaler = StandardScaler()

X_train = scaler.fit_transform(X_train)

X_test = scaler.remodel(X_test)

# Neural Community

mannequin = fashions.Sequential((

  layers.Dense(64, activation='relu', input_shape=(X_train.form(1),)),

  layers.Dense(32, activation='relu'),

  layers.Dense(len(np.distinctive(y_encoded)), activation='softmax')  # Guarantee output layer dimension matches variety of courses

))

mannequin.compile(optimizer="adam", loss="sparse_categorical_crossentropy", metrics=('accuracy'))

# Callbacks

early_stopping = EarlyStopping(monitor="val_loss", persistence=10, restore_best_weights=True)

model_checkpoint = ModelCheckpoint('best_model.keras', monitor="val_loss", save_best_only=True)

# Prepare the mannequin

historical past = mannequin.match(X_train, y_train, epochs=100, batch_size=32, validation_data=(X_test, y_test),

                   callbacks=(early_stopping, model_checkpoint), verbose=1)

# Consider the mannequin

train_loss, train_accuracy = mannequin.consider(X_train, y_train, verbose=0)

test_loss, test_accuracy = mannequin.consider(X_test, y_test, verbose=0)

print(f"Neural Community - Prepare Accuracy: {train_accuracy}, Check Accuracy: {test_accuracy}")

Die Bedeutung verschiedener Kennzahlen verstehen

1. Genauigkeit: Obwohl wichtig, spiegelt die Genauigkeit möglicherweise nicht die gesamte Leistung eines Modells wider, insbesondere bei unausgewogenen Klassenverteilungen.
2. Verlust: Die Verlustfunktion bewertet, wie intestine die vorhergesagten Werte mit den wahren Beschriftungen übereinstimmen. Kleinere Verlustwerte weisen auf eine höhere Genauigkeit hin.
3. Präzision, Rückruf und F1-Rating: Die Präzision bewertet die Richtigkeit positiver Vorhersagen, der Rückruf misst den Erfolg des Modells bei der Identifizierung aller positiven Fälle und der F1-Rating gleicht Präzision und Rückruf aus.
4. ROC-AUC: Die ROC-AUC-Metrik quantifiziert die Fähigkeit des Modells, unabhängig von der Schwellenwerteinstellung zwischen Klassen zu unterscheiden.

from sklearn.metrics import classification_report, roc_auc_score

# Predictions

y_test_pred_proba = mannequin.predict(X_test)

y_test_pred = np.argmax(y_test_pred_proba, axis=1)

# Classification report

print(classification_report(y_test, y_test_pred))

# ROC-AUC

roc_auc = roc_auc_score(y_test, y_test_pred_proba, multi_class="ovr")

print(f'ROC-AUC Rating: {roc_auc}')

Visualisierung der Modellleistung

Die Leistung des Modells während des Trainings kann durch das Aufzeichnen von Lernkurven für Genauigkeit und Verlust überprüft werden. Dadurch wird angezeigt, ob das Modell über- oder unterangepasst ist. Wir haben frühzeitig gestoppt, um eine Überanpassung zu verhindern, und dies hilft bei der Verallgemeinerung auf neue Daten.

import matplotlib.pyplot as plt

# Plot coaching & validation accuracy values

plt.determine(figsize=(14, 5))

plt.subplot(1, 2, 1)

plt.plot(historical past.historical past('accuracy'))

plt.plot(historical past.historical past('val_accuracy'))

plt.title('Mannequin Accuracy')

plt.xlabel('Epoch')

plt.ylabel('Accuracy')

plt.legend(('Prepare', 'Validation'), loc="higher left")

# Plot coaching & validation loss values

plt.subplot(1, 2, 2)

plt.plot(historical past.historical past('loss'))

plt.plot(historical past.historical past('val_loss'))

plt.title('Mannequin Loss')

plt.xlabel('Epoch')

plt.ylabel('Loss')

plt.legend(('Prepare', 'Validation'), loc="higher left")

plt.present()

Abschluss

Eine sorgfältige Auswertung ist entscheidend, um Probleme wie Über- und Unteranpassung zu vermeiden. Der Aufbau effektiver Klassifizierungsmodelle umfasst mehr als die Auswahl und Schulung des richtigen Algorithmus. Die Konsistenz und Zuverlässigkeit des Modells kann durch die Implementierung von Ensemblemethoden, Regularisierung, Feinabstimmung von Hyperparametern und Kreuzvalidierung verbessert werden. Obwohl unser kleiner Datensatz möglicherweise keine signifikante Überanpassung erfahren hat, stellt der Einsatz dieser Methoden sicher, dass die Modelle strong und präzise sind, was zu besseren Entscheidungen in praktischen Anwendungen führt.

Häufig gestellte Fragen