CKlassifizierungsmodelle sind leistungsstarke Werkzeuge des maschinellen Lernens, die es uns ermöglichen, die Klasse oder Kategorie einer Beobachtung anhand ihrer Merkmale vorherzusagen. In diesem Artikel möchten wir die Eignung zweier beliebter Klassifizierungsalgorithmen untersuchen und vergleichen: Logistische Regression und Assist Vector Machines (SVM). Um dies zu erreichen, erstellen wir zwei Klassifizierungsdatensätze, die mehr als 50 % informative Merkmale enthalten und über mindestens 2500 Zeilen verfügen. Darüber hinaus werden wir Skalierungstechniken auf die ersten fünf Merkmale anwenden und die Auswirkungen dieser Transformationen auf die endgültige Qualität unserer Klassifizierungsmodelle bewerten.
Problemstellung
- Erstellen Sie zwei Klassifizierungsdatensätze mit mehr als 50 % informativen Funktionen und mindestens 2500 Zeilen.
- Durchführung einer Artwork Skalierung der ersten fünf Options.
- Vergleichen Sie die Eignung der oben genannten Datensätze für die Durchführung logistischer Regression und Assist-Vektor-Maschinen.
- Prüfen Sie, ob die angewandte Transformation einen Einfluss auf die endgültige Qualität des Klassifizierungsmodells hat, und präsentieren Sie Ihre Ergebnisse übersichtlich.
Zielsetzung
- Erstellen von zwei Klassifizierungsdatensätzen, die mehr als 50 % informative Funktionen enthalten
- Sollte mindestens 2500 Zeilen haben
- So wenden Sie die Standardskalierung an
- Durchführung logistischer Regression und Assist-Vektor-Maschinen
- Anwenden anderer Klassifizierungsmodelle in Bezug auf erstellte Datensätze
Ansätze
- Importieren relevanter Bibliotheken für die Modellerstellung
- Importieren relevanter Bibliotheken für die Modellbewertung
- Verwendung relevanter Metriken zur Messung derselben
Überwachung
- Eine höhere mittlere Genauigkeit zusammen mit einer geringeren Standardabweichung bedeutet, dass der Datensatz einfacher zu klassifizieren ist und der oben verwendete Algorithmus für die jeweiligen Datensätze am besten geeignet ist.
Bibliotheken importieren
from sklearn.datasets import make_classification
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.svm import SVC
from sklearn.model_selection import cross_val_score
from sklearn.metrics import accuracy_score
from sklearn.neighbors import KNeighborsClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier
from sklearn.naive_bayes import GaussianNB
Datensätze erstellen
Um sicherzustellen, dass unsere Datensätze aussagekräftig sind, wählen wir sorgfältig Merkmale aus, die wesentlich zur Klassifizierungsaufgabe beitragen. Durch die Integration von mehr als 50 % informativen Funktionen wollen wir die Vorhersagekraft unserer Modelle verbessern. Darüber hinaus liefert uns eine beträchtliche Anzahl von Zeilen (mindestens 2500) ausreichend Daten, um unsere Modelle effektiv zu trainieren und auszuwerten.
# First dataset
X1, y1 = make_classification(n_samples=3000, n_features=10, n_informative=6, n_redundant=2, n_classes=2, random_state=42)# Second dataset
X2, y2 = make_classification(n_samples=4000, n_features=15, n_informative=9, n_redundant=3, n_classes=3, random_state=21)
Within the above cell We created two dataset the place the primary Dataet comprises 3000 rows with 10 options, the place 6 of them are informative and a pair of of them are redundant Whereas the second dataset comprises 4000 rows with 15 options the place 9 of them are informative and three of them are redundant.
Each dataset fulfill the situation to be stated as containing greater than 50% informative options and together with it it additionally meets the variety of rows requirement.
Right here the n class parameter defines the variety of lessons inthe dataset
Skalierung durchführen
Bevor wir unsere Modelle trainieren, wenden wir Skalierungstechniken auf die ersten fünf Merkmale unserer Datensätze an. Die Skalierung ist wichtig, um die Merkmalswerte zu normalisieren und auf einen ähnlichen Maßstab zu bringen und eine Verzerrung hin zu Merkmalen mit größeren Größen zu vermeiden. Durch die Anwendung der Skalierung können wir die Konvergenz und Leistung unserer Klassifizierungsalgorithmen verbessern und sicherstellen, dass alle Merkmale gleich behandelt werden.
# Create an occasion of the StandardScaler class
scaler = StandardScaler()# Match and remodel the primary 5 options of the primary dataset
X1[:, :5] = scaler.fit_transform(X1[:, :5])
Within the above cell we're utilizing StandardScaler and fit_transfrom technique to suit the scaler for the primary 5 options of the First Created Dataset.
The place after transfomation they are going to be having zero imply and unit variance. Then the scaler values are assigned again to the unique dataset
# Create an occasion of the StandardScaler class
scaler = StandardScaler()# Match and remodel the primary 5 options of the second dataset
X2[:, :5] = scaler.fit_transform(X2[:, :5])
It's just like what we carry out to the primary dataset the cell above present cell we're utilizing StandardScaler and fit_transfrom technique to suit the scaler for the primary 5 options of the Second Created Dataset.
The place after transfomation they are going to be having zero imply and unit variance. Then the scaler values are assigned again to the unique dataset
Durchführen logistischer Regression und Assist-Vektor-Maschinen
Sobald wir unsere Datensätze vorbereitet und die Funktionen skaliert haben, vergleichen wir die Eignung von logistischen Regressions- und Assist-Vektor-Maschinen für unsere Klassifizierungsaufgabe. Beide Algorithmen werden häufig zur binären Klassifizierung verwendet und bieten einzigartige Vor- und Nachteile. Wir bewerten die Leistung jedes Modells anhand geeigneter Bewertungsmetriken wie Genauigkeit, Präzision, Rückruf und F1-Rating. Dieser Vergleich liefert Einblicke in die Stärken und Schwächen jedes Algorithmus und hilft uns herauszufinden, welcher für unser spezifisches Klassifizierungsproblem besser geeignet ist.
# Logistic Regression on Dataset 1
lr1 = LogisticRegression()
scores_lr1 = cross_val_score(lr1, X1, y1, cv=5)
print("Logistic Regression on Dataset 1: Accuracy = %0.2f (+/- %0.2f)" % (scores_lr1.imply(), scores_lr1.std() * 2))# SVM on Dataset 1
Logistic Regression on Dataset 1: Accuracy = 0.89 (+/- 0.02)
svm1 = SVC()
scores_svm1 = cross_val_score(svm1, X1, y1, cv=5)
print("SVM on Dataset 1: Accuracy = %0.2f (+/- %0.2f)" % (scores_svm1.imply(), scores_svm1.std() * 2))
SVM on Dataset 1: Accuracy = 0.94 (+/- 0.02)
Within the above cell we're coaching and performing & additionally evaluating Logistic Regression & SVM(Assist Vector Machine) within the First Dataset utilizing the 5 fold Cross Validation.
Then we will the the Customary Deviation and Imply of the Accuracy Scores throughout the given Folds within the above cell
# Logistic Regression on Dataset 2
lr2 = LogisticRegression()
scores_lr2 = cross_val_score(lr2, X2, y2, cv=5)
print("Logistic Regression on Dataset 2: Accuracy = %0.2f (+/- %0.2f)" % (scores_lr2.imply(), scores_lr2.std() * 2))# SVM on Dataset 2
Logistic Regression on Dataset 2: Accuracy = 0.63 (+/- 0.01)
svm2 = SVC()
scores_svm2 = cross_val_score(svm2, X2, y2, cv=5)
print("SVM on Dataset 2: Accuracy = %0.2f (+/- %0.2f)" % (scores_svm2.imply(), scores_svm2.std() * 2))
SVM on Dataset 2: Accuracy = 0.89 (+/- 0.02)
The above cell is just like what we perfomed within the cell above present cell, the place mainly we're coaching and performing & additionally evaluating Logistic Regression & SVM(Assist Vector Machine) within the Second Dataset utilizing the 5 fold Cross Validation.
In Conclusion, This sort of comparability may also help us decide one of many dataset among the many datasets which might be most fitted with respect to Logistic Regression and Assist Vector Machine
Right here, greater imply accuracy together with decrease commonplace deviation implies that the dataset is less complicated to categorise and the above used algorithm are most fitted for the actual datasets.
Modellauswahl und Qualität des Modells
Überprüfung, ob die angewandte Transformation einen Einfluss auf die endgültige Qualität des Klassifizierungsmodells hat
Abschließend werden wir untersuchen, ob die angewandten Skalierungstransformationen einen Einfluss auf die endgültige Qualität unserer Klassifizierungsmodelle haben. Wir werden die Modelle sowohl anhand der ursprünglichen unskalierten Datensätze als auch der skalierten Datensätze trainieren und bewerten. Durch den Vergleich der Leistungsmetriken der Modelle in diesen verschiedenen Datensätzen können wir feststellen, ob der Skalierungsprozess die Klassifizierungsgenauigkeit verbessert oder beeinträchtigt. Diese Analyse wird es uns ermöglichen, Rückschlüsse auf die Wirksamkeit der Skalierung bei der Verbesserung der Vorhersagefähigkeiten unserer Klassifizierungsmodelle zu ziehen.
Ohne Skalierung
# With out Scaling
lr1_no_scaling = LogisticRegression()
scores_no_scaling = cross_val_score(lr1_no_scaling, X1, y1, cv=5)
acc_no_scaling = accuracy_score(y1, lr1_no_scaling.match(X1, y1).predict(X1))
print("Logistic Regression on Dataset 1 with out scaling:")
print(" Accuracy (CV): %0.2f (+/- %0.2f)" % (scores_no_scaling.imply(), scores_no_scaling.std() * 2))
print(" Accuracy (prepare): %0.2f" % acc_no_scaling)
print("-"*35)
lr2_no_scaling = LogisticRegression()
scores_no_scaling2 = cross_val_score(lr2_no_scaling, X2, y2, cv=5)
acc_no_scaling2 = accuracy_score(y2, lr2_no_scaling.match(X2, y2).predict(X2))
print("Logistic Regression on Dataset 2 with out scaling:")
print(" Accuracy (CV): %0.2f (+/- %0.2f)" % (scores_no_scaling2.imply(), scores_no_scaling2.std() * 2))
print(" Accuracy (prepare): %0.2f" % acc_no_scaling2)Logistic Regression on Dataset 1 with out scaling:
Accuracy (CV): 0.89 (+/- 0.02)
Accuracy (prepare): 0.90
-----------------------------------
Logistic Regression on Dataset 2 with out scaling:
Accuracy (CV): 0.63 (+/- 0.01)
Accuracy (prepare): 0.64
Within the Above cell we're mainly coaching and evaluating the Logistic Regression Mannequin on the unscaled Dataset that imply with out making use of Characteristic Scaling together with with utilizing 5 fold Cross Validation.
Then we're fetching the accuracy rating after the completion of Coaching.
Mit Characteristic-Skalierung
# Characteristic scaling
scaler1 = StandardScaler()
X1_scaled = scaler1.fit_transform(X1)scaler2 = StandardScaler()
X2_scaled = scaler2.fit_transform(X2)# With Scaling
lr1_scaling = LogisticRegression()
scores_scaling = cross_val_score(lr1_scaling, X1_scaled, y1, cv=5)
acc_scaling = accuracy_score(y1, lr1_scaling.match(X1_scaled, y1).predict(X1_scaled))
print("Logistic Regression on Dataset 1 with scaling:")
print(" Accuracy (CV): %0.2f (+/- %0.2f)" % (scores_scaling.imply(), scores_scaling.std() * 2))
print(" Accuracy (prepare): %0.2f" % acc_scaling)lr2_scaling = LogisticRegression()
Logistic Regression on Dataset 1 with scaling:
scores_scaling2 = cross_val_score(lr2_scaling, X2_scaled, y2, cv=5)
acc_scaling2 = accuracy_score(y2, lr2_scaling.match(X2_scaled, y2).predict(X2_scaled))
print("Logistic Regression on Dataset 2 with scaling:")
print(" Accuracy (CV): %0.2f (+/- %0.2f)" % (scores_scaling2.imply(), scores_scaling2.std() * 2))
print(" Accuracy (prepare): %0.2f" % acc_scaling2)
Accuracy (CV): 0.89 (+/- 0.02)
Accuracy (prepare): 0.90
Logistic Regression on Dataset 2 with scaling:
Accuracy (CV): 0.63 (+/- 0.01)
Accuracy (prepare): 0.64
Within the Above cell we're mainly performing the identical factor which includes coaching and evaluating the Logistic Regression Mannequin however on an scaled dataset with the identical variety of cross validation folds
Then we're fetching the accuracy rating after the completion of Coaching and evaluating the efficiency metrics between the given created Fashions
Dasselbe auf andere Klassifizierungsmodelle anwenden
Unterstützt Vektormaschine
# Assist Vector Machinesprint("*"*30)
print("Assist Vector Machines With out-Scaling")
print("*"*30)
svc1_no_scaling = SVC()
scores_svc_no_scaling = cross_val_score(svc1_no_scaling, X1, y1, cv=5)
acc_svc_no_scaling = accuracy_score(y1, svc1_no_scaling.match(X1, y1).predict(X1))
print("Assist Vector Machines on Dataset 1 with out scaling:")
print(" Accuracy (CV): %0.2f (+/- %0.2f)" % (scores_svc_no_scaling.imply(), scores_svc_no_scaling.std() * 2))
print(" Accuracy (prepare): %0.2f" % acc_svc_no_scaling)svc2_no_scaling = SVC()
scores_svc_no_scaling2 = cross_val_score(svc2_no_scaling, X2, y2, cv=5)
acc_svc_no_scaling2 = accuracy_score(y2, svc2_no_scaling.match(X2, y2).predict(X2))
print("Assist Vector Machines on Dataset 2 with out scaling:")
print(" Accuracy (CV): %0.2f (+/- %0.2f)" % (scores_svc_no_scaling2.imply(), scores_svc_no_scaling2.std() * 2))
print(" Accuracy (prepare): %0.2f" % acc_svc_no_scaling2)
print("*"*30)
print("Assist Vector Machines With-Scaling")
print("*"*30)svc1_scaling = SVC()
scores_svc_scaling = cross_val_score(svc1_scaling, X1_scaled, y1, cv=5)
acc_svc_scaling = accuracy_score(y1, svc1_scaling.match(X1_scaled, y1).predict(X1_scaled))
print("Assist Vector Machines on Dataset 1 with scaling:")
print(" Accuracy (CV): %0.2f (+/- %0.2f)" % (scores_svc_scaling.imply(), scores_svc_scaling.std() * 2))
print(" Accuracy (prepare): %0.2f" % acc_svc_scaling)svc2_scaling = SVC()
******************************
scores_svc_scaling2 = cross_val_score(svc2_scaling, X2_scaled, y2, cv=5)
acc_svc_scaling2 = accuracy_score(y2, svc2_scaling.match(X2_scaled, y2).predict(X2_scaled))
print("Assist Vector Machines on Dataset 2 with scaling:")
print(" Accuracy (CV): %0.2f (+/- %0.2f)" % (scores_svc_scaling2.imply(), scores_svc_scaling2.std() * 2))
print(" Accuracy (prepare): %0.2f" % acc_svc_scaling2)
Assist Vector Machines With out-Scaling
******************************
Assist Vector Machines on Dataset 1 with out scaling:
Accuracy (CV): 0.94 (+/- 0.02)
Accuracy (prepare): 0.95
Assist Vector Machines on Dataset 2 with out scaling:
Accuracy (CV): 0.89 (+/- 0.02)
Accuracy (prepare): 0.92
******************************
Assist Vector Machines With-Scaling
******************************
Assist Vector Machines on Dataset 1 with scaling:
Accuracy (CV): 0.94 (+/- 0.02)
Accuracy (prepare): 0.95
Assist Vector Machines on Dataset 2 with scaling:
Accuracy (CV): 0.91 (+/- 0.02)
Accuracy (prepare): 0.93
Ok-Nächste Nachbarn
# Ok-Nearest Neighbors
print("*"*30)
print("Ok-Nearest Neighbors With out-Scaling")
print("*"*30)
knn1_no_scaling = KNeighborsClassifier()
scores_knn_no_scaling = cross_val_score(knn1_no_scaling, X1, y1, cv=5)
acc_knn_no_scaling = accuracy_score(y1, knn1_no_scaling.match(X1, y1).predict(X1))
print("Ok-Nearest Neighbors on Dataset 1 with out scaling:")
print(" Accuracy (CV): %0.2f (+/- %0.2f)" % (scores_knn_no_scaling.imply(), scores_knn_no_scaling.std() * 2))
print(" Accuracy (prepare): %0.2f" % acc_knn_no_scaling)knn2_no_scaling = KNeighborsClassifier()
scores_knn_no_scaling2 = cross_val_score(knn2_no_scaling, X2, y2, cv=5)
acc_knn_no_scaling2 = accuracy_score(y2, knn2_no_scaling.match(X2, y2).predict(X2))
print("Ok-Nearest Neighbors on Dataset 2 with out scaling:")
print(" Accuracy (CV): %0.2f (+/- %0.2f)" % (scores_knn_no_scaling2.imply(), scores_knn_no_scaling2.std() * 2))
print(" Accuracy (prepare): %0.2f" % acc_knn_no_scaling2)
print("-"*35)
print("*"*30)
print("Ok-Nearest Neighbors With-Scaling")
print("*"*30)
knn1_scaling = KNeighborsClassifier()
scores_knn_scaling = cross_val_score(knn1_scaling, X1_scaled, y1, cv=5)
acc_knn_scaling = accuracy_score(y1, knn1_scaling.match(X1_scaled, y1).predict(X1_scaled))
print("Ok-Nearest Neighbors on Dataset 1 with scaling:")
print(" Accuracy (CV): %0.2f (+/- %0.2f)" % (scores_knn_scaling.imply(), scores_knn_scaling.std() * 2))
print(" Accuracy (prepare): %0.2f" % acc_knn_scaling)knn2_scaling = KNeighborsClassifier()
******************************
scores_knn_scaling2 = cross_val_score(knn2_scaling, X2_scaled, y2, cv=5)
acc_knn_scaling2 = accuracy_score(y2, knn2_scaling.match(X2_scaled, y2).predict(X2_scaled))
print("Ok-Nearest Neighbors on Dataset 2 with scaling:")
print(" Accuracy (CV): %0.2f (+/- %0.2f)" % (scores_knn_scaling2.imply(), scores_knn_scaling2.std() * 2))
print(" Accuracy (prepare): %0.2f" % acc_knn_scaling2)
Ok-Nearest Neighbors With out-Scaling
******************************
Ok-Nearest Neighbors on Dataset 1 with out scaling:
Accuracy (CV): 0.93 (+/- 0.02)
Accuracy (prepare): 0.95
Ok-Nearest Neighbors on Dataset 2 with out scaling:
Accuracy (CV): 0.85 (+/- 0.02)
Accuracy (prepare): 0.91
-----------------------------------
******************************
Ok-Nearest Neighbors With-Scaling
******************************
Ok-Nearest Neighbors on Dataset 1 with scaling:
Accuracy (CV): 0.93 (+/- 0.02)
Accuracy (prepare): 0.95
Ok-Nearest Neighbors on Dataset 2 with scaling:
Accuracy (CV): 0.87 (+/- 0.02)
Accuracy (prepare): 0.92
Entscheidungsbäume
# Choice Bushes
print("*"*30)
print("Choice Bushes With out-Scaling")
print("*"*30)
dt1_no_scaling = DecisionTreeClassifier()
scores_dt_no_scaling = cross_val_score(dt1_no_scaling, X1, y1, cv=5)
acc_dt_no_scaling = accuracy_score(y1, dt1_no_scaling.match(X1, y1).predict(X1))
print("Choice Bushes on Dataset 1 with out scaling:")
print(" Accuracy (CV): %0.2f (+/- %0.2f)" % (scores_dt_no_scaling.imply(), scores_dt_no_scaling.std() * 2))
print(" Accuracy (prepare): %0.2f" % acc_dt_no_scaling)dt2_no_scaling = DecisionTreeClassifier()
scores_dt_no_scaling2 = cross_val_score(dt2_no_scaling, X2, y2, cv=5)
acc_dt_no_scaling2 = accuracy_score(y2, dt2_no_scaling.match(X2, y2).predict(X2))
print("Choice Bushes on Dataset 2 with out scaling:")
print(" Accuracy (CV): %0.2f (+/- %0.2f)" % (scores_dt_no_scaling2.imply(), scores_dt_no_scaling2.std() * 2))
print(" Accuracy (prepare): %0.2f" % acc_dt_no_scaling2)
print("-"*35)print("*"*30)
print("Choice Bushes with With-Scaling")
print("*"*30)
scaler1 = StandardScaler()
X1_scaled = scaler1.fit_transform(X1)
dt1_scaling = DecisionTreeClassifier()
scores_dt_scaling = cross_val_score(dt1_scaling, X1_scaled, y1, cv=5)
acc_dt_scaling = accuracy_score(y1, dt1_scaling.match(X1_scaled, y1).predict(X1_scaled))
print("Choice Bushes on Dataset 1 with scaling:")
print(" Accuracy (CV): %0.2f (+/- %0.2f)" % (scores_dt_scaling.imply(), scores_dt_scaling.std() * 2))
print(" Accuracy (prepare): %0.2f" % acc_dt_scaling)scaler2 = StandardScaler()
******************************
X2_scaled = scaler2.fit_transform(X2)
dt2_scaling = DecisionTreeClassifier()
scores_dt_scaling2 = cross_val_score(dt2_scaling, X2_scaled, y2, cv=5)
acc_dt_scaling2 = accuracy_score(y2, dt2_scaling.match(X2_scaled, y2).predict(X2_scaled))
print("Choice Bushes on Dataset 2 with scaling:")
print(" Accuracy (CV): %0.2f (+/- %0.2f)" % (scores_dt_scaling2.imply(), scores_dt_scaling2.std() * 2))
print(" Accuracy (prepare): %0.2f" % acc_dt_scaling2)
Choice Bushes With out-Scaling
******************************
Choice Bushes on Dataset 1 with out scaling:
Accuracy (CV): 0.88 (+/- 0.01)
Accuracy (prepare): 1.00
Choice Bushes on Dataset 2 with out scaling:
Accuracy (CV): 0.77 (+/- 0.04)
Accuracy (prepare): 1.00
-----------------------------------
******************************
Choice Bushes with With-Scaling
******************************
Choice Bushes on Dataset 1 with scaling:
Accuracy (CV): 0.88 (+/- 0.02)
Accuracy (prepare): 1.00
Choice Bushes on Dataset 2 with scaling:
Accuracy (CV): 0.77 (+/- 0.04)
Accuracy (prepare): 1.00
Zufälliger Wald
# Random Forest
print("*"*30)
print("Random Forest With out-Scaling")
print("*"*30)
rf1_no_scaling = RandomForestClassifier()
scores_rf_no_scaling = cross_val_score(rf1_no_scaling, X1, y1, cv=5)
acc_rf_no_scaling = accuracy_score(y1, rf1_no_scaling.match(X1, y1).predict(X1))
print("Random Forest on Dataset 1 with out scaling:")
print(" Accuracy (CV): %0.2f (+/- %0.2f)" % (scores_rf_no_scaling.imply(), scores_rf_no_scaling.std() * 2))
print(" Accuracy (prepare): %0.2f" % acc_rf_no_scaling)rf2_no_scaling = RandomForestClassifier()
scores_rf_no_scaling2 = cross_val_score(rf2_no_scaling, X2, y2, cv=5)
acc_rf_no_scaling2 = accuracy_score(y2, rf2_no_scaling.match(X2, y2).predict(X2))
print("Random Forest on Dataset 2 with out scaling:")
print(" Accuracy (CV): %0.2f (+/- %0.2f)" % (scores_rf_no_scaling2.imply(), scores_rf_no_scaling2.std() * 2))
print(" Accuracy (prepare): %0.2f" % acc_rf_no_scaling2)
print("-"*35)print("*"*30)
print("Random Forest with With-Scaling")
print("*"*30)
rf1_scaling = RandomForestClassifier()
scores_rf_scaling = cross_val_score(rf1_scaling, X1_scaled, y1, cv=5)
acc_rf_scaling = accuracy_score(y1, rf1_scaling.match(X1_scaled, y1).predict(X1_scaled))
print("Random Forest on Dataset 1 with scaling:")
print(" Accuracy (CV): %0.2f (+/- %0.2f)" % (scores_rf_scaling.imply(), scores_rf_scaling.std() * 2))
print(" Accuracy (prepare): %0.2f" % acc_rf_scaling)rf2_scaling = RandomForestClassifier()
******************************
scores_rf_scaling2 = cross_val_score(rf2_scaling, X2_scaled, y2, cv=5)
acc_rf_scaling2 = accuracy_score(y2, rf2_scaling.match(X2_scaled, y2).predict(X2_scaled))
print("Random Forest on Dataset 2 with scaling:")
print(" Accuracy (CV): %0.2f (+/- %0.2f)" % (scores_rf_scaling2.imply(), scores_rf_scaling2.std() * 2))
print(" Accuracy (prepare): %0.2f" % acc_rf_scaling2)
Random Forest With out-Scaling
******************************
Random Forest on Dataset 1 with out scaling:
Accuracy (CV): 0.93 (+/- 0.03)
Accuracy (prepare): 1.00
Random Forest on Dataset 2 with out scaling:
Accuracy (CV): 0.88 (+/- 0.02)
Accuracy (prepare): 1.00
-----------------------------------
******************************
Random Forest with With-Scaling
******************************
Random Forest on Dataset 1 with scaling:
Accuracy (CV): 0.93 (+/- 0.02)
Accuracy (prepare): 1.00
Random Forest on Dataset 2 with scaling:
Accuracy (CV): 0.88 (+/- 0.02)
Accuracy (prepare): 1.00# Naive Bayes
print("*"*30)
print("Naive Bayes with With out-Scaling")
print("*"*30)
nb1_no_scaling = GaussianNB()
scores_nb_no_scaling = cross_val_score(nb1_no_scaling, X1, y1, cv=5)
acc_nb_no_scaling = accuracy_score(y1, nb1_no_scaling.match(X1, y1).predict(X1))
print("Naive Bayes on Dataset 1 with out scaling:")
print(" Accuracy (CV): %0.2f (+/- %0.2f)" % (scores_nb_no_scaling.imply(), scores_nb_no_scaling.std() * 2))
print(" Accuracy (prepare): %0.2f" % acc_nb_no_scaling)nb2_no_scaling = GaussianNB()
scores_nb_no_scaling2 = cross_val_score(nb2_no_scaling, X2, y2, cv=5)
acc_nb_no_scaling2 = accuracy_score(y2, nb2_no_scaling.match(X2, y2).predict(X2))
print("Naive Bayes on Dataset 2 with out scaling:")
print(" Accuracy (CV): %0.2f (+/- %0.2f)" % (scores_nb_no_scaling2.imply(), scores_nb_no_scaling2.std() * 2))
print(" Accuracy (prepare): %0.2f" % acc_nb_no_scaling2)
print("")
print("-"*30)
print("Naive Bayes with Scaling")
print("-"*30)
nb1_scaling = GaussianNB()
scores_nb_scaling = cross_val_score(nb1_scaling, X1_scaled, y1, cv=5)
acc_nb_scaling = accuracy_score(y1, nb1_scaling.match(X1_scaled, y1).predict(X1_scaled))
print("Naive Bayes on Dataset 1 with scaling:")
print(" Accuracy (CV): %0.2f (+/- %0.2f)" % (scores_nb_scaling.imply(), scores_nb_scaling.std() * 2))
print(" Accuracy (prepare): %0.2f" % acc_nb_scaling)nb2_scaling = GaussianNB()
Naive Bayes with With out-Scaling
scores_nb_scaling2 = cross_val_score(nb2_scaling, X2_scaled, y2, cv=5)
acc_nb_scaling2 = accuracy_score(y2, nb2_scaling.match(X2_scaled, y2).predict(X2_scaled))
print("Naive Bayes on Dataset 2 with scaling:")
print(" Accuracy (CV): %0.2f (+/- %0.2f)" % (scores_nb_scaling2.imply(), scores_nb_scaling2.std() * 2))
print(" Accuracy (prepare): %0.2f" % acc_nb_scaling2)
Naive Bayes on Dataset 1 with out scaling:
Accuracy (CV): 0.86 (+/- 0.03)
Accuracy (prepare): 0.86
Naive Bayes on Dataset 2 with out scaling:
Accuracy (CV): 0.65 (+/- 0.03)
Accuracy (prepare): 0.65------------------------------
Naive Bayes with Scaling
------------------------------
Naive Bayes on Dataset 1 with scaling:
Accuracy (CV): 0.86 (+/- 0.03)
Accuracy (prepare): 0.86
Naive Bayes on Dataset 2 with scaling:
Accuracy (CV): 0.65 (+/- 0.03)
Accuracy (prepare): 0.65
Abschluss
In diesem Artikel haben wir mit einer vergleichenden Studie zweier beliebter Klassifizierungsalgorithmen begonnen: Logistic Regression und Assist Vector Machines und einigen anderen. Wir haben informative Klassifizierungsdatensätze mit einer beträchtlichen Anzahl von Zeilen erstellt und Skalierungstechniken angewendet, um die Merkmalswerte zu normalisieren. Durch die Bewertung der Leistung der Modelle sowohl bei skalierten als auch bei nicht skalierten Datensätzen haben wir Erkenntnisse über die Auswirkungen der Skalierung auf die Klassifizierungsgenauigkeit gewonnen. Diese Untersuchung bietet wertvolle Hinweise für Praktiker, die das am besten geeignete Klassifizierungsmodell und die am besten geeigneten Vorverarbeitungstechniken für ihre spezifischen Aufgaben auswählen möchten.
Vielen Dank, dass Sie mich auf dieser Reise zur Erforschung von Klassifizierungsmodellen und ihrer Eignung für verschiedene Datensätze begleitet haben. Ich hoffe, Sie fanden diesen Artikel aufschlussreich und informativ. Denken Sie daran, dass es im Bereich des maschinellen Lernens entscheidend ist, die Stärken und Schwächen verschiedener Algorithmen zu verstehen, um genaue Vorhersagen zu erzielen. Egal, ob Sie an logistischer Regression, Assist-Vektor-Maschinen oder einer anderen Klassifizierungstechnik arbeiten, experimentieren, lernen und verbessern Sie sich weiter. Bleiben Sie neugierig, bleiben Sie leidenschaftlich und erweitern Sie weiterhin die Grenzen des Möglichen. Viel Spaß beim Lernen!
