Komma igång med Scikit-learn för klassificering i maskininlärning

Återutgiven av Platon

anhängare: 0

Komma igång med Scikit-learn för klassificering i maskininlärning

Bild av redaktör

Scikit-learn är ett av de mest använda maskininlärningsbiblioteken byggt i python. Dess popularitet kan tillskrivas dess enkla och konsekventa kodstruktur som är vänlig för nybörjarutvecklare. Det finns också en hög nivå av stöd tillgängligt tillsammans med flexibilitet för att integrera tredjepartsfunktioner vilket gör biblioteket robust och lämpligt för produktion. Biblioteket innehåller flera maskininlärningsmodeller för klassificering, regression och klustring. I den här handledningen kommer vi att utforska problemet med multiklassklassificering genom olika algoritmer. Låt oss dyka direkt in i det och bygga våra scikit-learn-modeller.

pip install scikit-learn

Vi kommer att använda datauppsättningen "Wine" som är tillgänglig i datauppsättningsmodulen i scikit-learn. Denna datauppsättning består av 178 prover och totalt 3 klasser. Datauppsättningen är redan förbehandlad och konverterad till funktionsvektorer, så vi kan direkt använda den för att träna våra modeller.

from sklearn.datasets import load_wine X, y = load_wine(return_X_y=True)

Vi kommer att behålla 67 % av data för träning och resten 33 % för testning.

from sklearn.model_selection import train_test_split X_train, X_test, y_train, y_test = train_test_split( X, y, test_size=0.33, random_state=42
)

Nu kommer vi att experimentera med 5 olika modeller av olika komplexitet och utvärdera deras resultat på vår datauppsättning.

model_lr = LogisticRegression()
model_lr.fit(X_train, y_train)
y_pred_lr = model_lr.predict(X_test) print("Accuracy Score: ", accuracy_score(y_pred_lr, y_test))
print(classification_report(y_pred_lr, y_test))

Produktion

Accuracy Score: 0.9830508474576272 precision recall f1-score support 0 1.00 0.95 0.98 21 1 0.96 1.00 0.98 23 2 1.00 1.00 1.00 15 accuracy 0.98 59 macro avg 0.99 0.98 0.98 59
weighted avg 0.98 0.98 0.98 59

model_knn = KNeighborsClassifier(n_neighbors=1)
model_knn.fit(X_train, y_train)
y_pred_knn = model_knn.predict(X_test) print("Accuracy Score:", accuracy_score(y_pred_knn, y_test))
print(classification_report(y_pred_knn, y_test))

Produktion

Accuracy Score: 0.7796610169491526 precision recall f1-score support 0 0.90 0.78 0.84 23 1 0.75 0.82 0.78 22 2 0.67 0.71 0.69 14 accuracy 0.78 59 macro avg 0.77 0.77 0.77 59
weighted avg 0.79 0.78 0.78 59

Vid ändring av parametern 'n_neighbors=2' observerar vi en minskning av värdet av noggrannhet. Därför visar det att informationen är enkel nog och uppnår bättre inlärning med en enda granne att överväga.

Produktion

Accuracy Score: 0.6949152542372882 precision recall f1-score support 0 0.90 0.72 0.80 25 1 0.75 0.69 0.72 26 2 0.33 0.62 0.43 8 accuracy 0.69 59 macro avg 0.66 0.68 0.65 59
weighted avg 0.76 0.69 0.72 59

from sklearn.naive_bayes import GaussianNB model_nb = GaussianNB()
model_nb.fit(X_train, y_train)
y_pred_nb = model_nb.predict(X_test) print("Accuracy Score:", accuracy_score(y_pred_nb, y_test))
print(classification_report(y_pred_nb, y_test))

Produktion

Accuracy Score: 1.0 precision recall f1-score support 0 1.00 1.00 1.00 20 1 1.00 1.00 1.00 24 2 1.00 1.00 1.00 15 accuracy 1.00 59 macro avg 1.00 1.00 1.00 59
weighted avg 1.00 1.00 1.00 59

from sklearn.tree import DecisionTreeClassifier model_dtclassifier = DecisionTreeClassifier()
model_dtclassifier.fit(X_train, y_train)
y_pred_dtclassifier = model_dtclassifier.predict(X_test) print("Accuracy Score:", accuracy_score(y_pred_dtclassifier, y_test))
print(classification_report(y_pred_dtclassifier, y_test))

Produktion

Accuracy Score: 0.9661016949152542 precision recall f1-score support 0 0.95 0.95 0.95 20 1 1.00 0.96 0.98 25 2 0.93 1.00 0.97 14 accuracy 0.97 59 macro avg 0.96 0.97 0.97 59
weighted avg 0.97 0.97 0.97 59

from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import RandomizedSearchCV def get_best_parameters(): params = { "n_estimators": [10, 50, 100], "max_features": ["auto", "sqrt", "log2"], "max_depth": [5, 10, 20, 50], "min_samples_split": [2, 4, 6], "min_samples_leaf": [2, 4, 6], "bootstrap": [True, False], } model_rfclassifier = RandomForestClassifier(random_state=42) rf_randomsearch = RandomizedSearchCV( estimator=model_rfclassifier, param_distributions=params, n_iter=5, cv=3, verbose=2, random_state=42, ) rf_randomsearch.fit(X_train, y_train) best_parameters = rf_randomsearch.best_params_ print("Best Parameters:", best_parameters) return best_parameters parameters_rfclassifier = get_best_parameters() model_rfclassifier = RandomForestClassifier( **parameters_rfclassifier, random_state=42
) model_rfclassifier.fit(X_train, y_train) y_pred_rfclassifier = model_rfclassifier.predict(X_test) print("Accuracy Score:", accuracy_score(y_pred_rfclassifier, y_test))
print(classification_report(y_pred_rfclassifier, y_test))

Produktion


Best Parameters: {'n_estimators': 100, 'min_samples_split': 6, 'min_samples_leaf': 4, 'max_features': 'log2', 'max_depth': 5, 'bootstrap': True}
Accuracy Score: 0.9830508474576272 precision recall f1-score support 0 1.00 0.95 0.98 21 1 0.96 1.00 0.98 23 2 1.00 1.00 1.00 15 accuracy 0.98 59 macro avg 0.99 0.98 0.98 59
weighted avg 0.98 0.98 0.98 59

I den här algoritmen utförde vi lite hyperparameterjustering för att uppnå bästa noggrannhet. Vi definierade ett parameterrutnät som består av flera värden att välja mellan för varje parameter. Vidare använde vi Randomized Search CV-algoritmen för att söka efter det bästa parameterutrymmet för modellen. Slutligen matar vi de erhållna parametrarna till klassificeraren och tränar modellen.

Modeller	Noggrannhet	Observationer
Logistisk återgång	98.30%	Uppnår stor noggrannhet. Modellen kan generalisera väl på testdatauppsättningen.
K-närmaste grannar	77.96%	Algoritmen kan inte lära sig datarepresentationen väl.
Naiva Bayes	100%	Modellen är mindre komplex och därför överpassar den data för att erhålla absolut noggrannhet.
Decision Tree Classifier	96.61%	Uppnår anständig noggrannhet.
Random Forest Classifier	98.30%	Eftersom det är ett ensemblebaserat tillvägagångssätt presterar det bättre än Decision Tree. Att utföra hyperparameterjustering gör att den uppnår liknande noggrannhet som logistisk regression.

I den här handledningen lärde vi oss hur man kommer igång med att bygga och träna maskininlärningsmodeller i scikit-learn. Vi implementerade och utvärderade några algoritmer för att få en grundläggande uppfattning om deras prestanda. Man kan alltid använda avancerade strategier för funktionsteknik, hyperparameterjustering eller träning för att förbättra prestandan. För att läsa mer om funktionerna som scikit-learn erbjuder, gå till den officiella dokumentationen - Introduktion till maskininlärning med scikit-learn, Maskininlärning i Python med scikit-learn.

Yesha Shastri är en passionerad AI-utvecklare och skribent som ägnar sig åt masterexamen i maskininlärning från Université de Montréal. Yesha är intresserad av att utforska ansvarsfulla AI-tekniker för att lösa utmaningar som gynnar samhället och dela sina lärdomar med samhället.