Scikit-learn is een open-source Python-bibliotheek die het proces van het bouwen van machine learning-modellen vereenvoudigt. Het biedt een schone en consistente interface waarmee zowel beginners als ervaren gebruikers efficiënt kunnen werken.

• Ondersteunt taken zoals classificatieregressieclustering en voorverwerking
• Maakt het bouwen van modellen snel en betrouwbaar
• Biedt kant-en-klare tools voor training en evaluatie
• Vermindert de complexiteit door handmatige implementatie van algoritmen te vermijden

Scikit-learn installeren en gebruiken

Voordat we modellen gaan bouwen, moeten we deze installeren Scikit-leren. Het vereist Python 3.8 of nieuwer en is afhankelijk van twee belangrijke bibliotheken: NumPy En SciPy. Zorg ervoor dat deze eerst zijn geïnstalleerd.

Om Scikit-learn te installeren, voert u de volgende opdracht uit:

pip install -U scikit-learn

Hiermee wordt de nieuwste versie van Scikit-learn gedownload en geïnstalleerd, samen met de afhankelijkheden ervan. Laten we de verschillende stappen bekijken die betrokken zijn bij het bouwen van Model met behulp van de Scikit-learn-bibliotheek.

Stap 1: Een dataset laden

Een dataset bestaat uit:

• Kenmerken (X): Voer variabelen in die de gegevens beschrijven
• Doel (j): De waarde die we willen voorspellen

Scikit-learn biedt ingebouwde datasets zoals Iris Digits en Boston Housing. Met behulp van de Iris-dataset:

• load_iris() laadt de gegevens
• X slaat functiegegevens op
• y slaat doellabels op
• feature_names en target_names geven beschrijvende namen

We kunnen de eerste paar rijen inspecteren om de structuur te begrijpen. Voor aangepaste datasets wordt Pandas vaak gebruikt om externe bestanden zoals CSV's te laden.

Linux hernoemen map

from sklearn.datasets import load_iris iris = load_iris() X = iris.data y = iris.target feature_names = iris.feature_names target_names = iris.target_names print('Feature names:' feature_names) print('Target names:' target_names) print('nType of X is:' type(X)) print('nFirst 5 rows of X:n' X[:5]) 

Uitgang: 

Soms moeten we aan onze eigen aangepaste gegevens werken, waarna we een externe dataset laden. Hiervoor kunnen we gebruik maken van de panda's bibliotheek voor het eenvoudig laden en manipuleren van datasets.

Hiervoor kunt u ons artikel raadplegen Hoe een csv-bestand in panda's te importeren ?

Stap 2: De gegevensset splitsen

Om een ​​model eerlijk te evalueren, splitsen we de gegevens op in:

• Trainingsset: Wordt gebruikt om het model te trainen
• Testset: wordt gebruikt om te evalueren hoe goed het model generaliseert

Met behulp van train_test_split splitsen we de Iris-dataset zodat 60% voor training is en 40% voor testen (test_size=0,4). random_state=1 zorgt voor reproduceerbaarheid.

Na het splitsen krijgen we:

• X_train y_train -> Trainingsgegevens
• X_test y_test -> Gegevens testen

Door de vormen te controleren, worden de gegevens correct gesplitst.

from sklearn.model_selection import train_test_split X_train X_test y_train y_test = train_test_split(X y test_size=0.4 random_state=1) 

Laten we nu de Vormen van de gesplitste gegevens om ervoor te zorgen dat beide sets de juiste gegevensverhoudingen hebben, waardoor mogelijke fouten bij modelevaluatie of -training worden vermeden.

print('X_train Shape:' X_train.shape) print('X_test Shape:' X_test.shape) print('Y_train Shape:' y_train.shape) print('Y_test Shape:' y_test.shape) 

Uitgang:

Stap 3: omgaan met categorische gegevens

Machine learning-algoritmen werken met numerieke invoer, dus categorische (tekst)gegevens moeten worden omgezet in cijfers. Als modellen niet correct worden gecodeerd, kunnen categorieën verkeerd worden geïnterpreteerd. Scikit-learn biedt meerdere coderingsmethoden:

1. Labelcodering : Het converteert elke categorie naar een uniek geheel getal. In een kolom met categorieën als 'kat', 'hond' en 'vogel' zou het deze bijvoorbeeld omzetten naar respectievelijk 0,1 en 2. Deze methode werkt goed als de categorieën een betekenisvolle volgorde hebben, zoals Laag Midden en Hoog.

• LabelEncoder(): Het is geïnitialiseerd om een ​​encoderobject te maken dat categorische waarden omzet in numerieke labels.
• fit_transform(): Deze methode past de encoder eerst aan de categorische gegevens aan en transformeert vervolgens de categorieën in overeenkomstige numerieke labels.

from sklearn.preprocessing import LabelEncoder categorical_feature = ['cat' 'dog' 'dog' 'cat' 'bird'] encoder = LabelEncoder() encoded_feature = encoder.fit_transform(categorical_feature) print('Encoded feature:' encoded_feature) 

Uitgang:

Gecodeerde functie: [1 2 2 1 0]

2. One-Hot-codering : One-Hot Encoding creëert afzonderlijke binaire kolommen voor elke categorie. Dit is handig als categorieën geen natuurlijke volgorde hebben. Voorbeeld: kat hond vogel -> 3 nieuwe kolommen (kat/hond/vogel) met 1s en 0s.

• De invoer moet worden omgevormd tot een 2D-array
• OneHotEncoder(sparse_output=False) genereert binaire kolommen

from sklearn.preprocessing import OneHotEncoder import numpy as np categorical_feature = ['cat' 'dog' 'dog' 'cat' 'bird'] categorical_feature = np.array(categorical_feature).reshape(-1 1) encoder = OneHotEncoder(sparse_output=False) encoded_feature = encoder.fit_transform(categorical_feature) print('OneHotEncoded feature:n' encoded_feature) 

Uitgang:

Naast Label Encoding en One-Hot Encoding zijn er nog andere technieken zoals Gemiddelde codering .

Stap 4: Het model trainen

Nu onze gegevens gereed zijn, is het tijd om een ​​machine learning-model te trainen. Scikit-learn heeft veel algoritmen met een consistente interface voor het voorspellen en evalueren van trainingen. Hier zullen we gebruiken Logistieke regressie als voorbeeld.

Opmerking : We zullen niet ingaan op de details van hoe het algoritme werkt, omdat we alleen geïnteresseerd zijn in het begrijpen van de implementatie ervan. 

• log_reg = LogistiekeRegressie(max_iter=200): Een logistisch regressieclassificatieobject maken.
• log_reg.fit(X_train y_train): Dit gebruiken het logistische regressiemodel past de parameters van het model aan zodat deze het beste bij de gegevens passen.

from sklearn.linear_model import LogisticRegression log_reg = LogisticRegression(max_iter=200) log_reg.fit(X_train y_train) 

Stap 5: Maak voorspellingen

Eenmaal getraind gebruiken we het model om voorspellingen te doen over de testgegevens X_test door de voorspellende methode aan te roepen. Dit retourneert voorspelde labels y_pred.

• log_reg.predict: Het maakt gebruik van een getraind logistisch regressiemodel om labels voor de testgegevens X_test te voorspellen.

y_pred = log_reg.predict(X_test) 

Stap 6: Modelnauwkeurigheid evalueren

Controleer hoe goed ons model presteert door y_test en y_pred te vergelijken. Hier gebruiken we de methode accuratesse_score van de metrische module.

git push-opdracht

from sklearn import metrics print('Logistic Regression model accuracy:' metrics.accuracy_score(y_test y_pred)) 

Uitgang:

Nauwkeurigheid van het logistieke regressiemodel: 0,9666666666666667

Nu willen we dat ons model voorspellingen doet op basis van nieuwe voorbeeldgegevens. Vervolgens kan de voorbeeldinvoer eenvoudigweg worden doorgegeven op dezelfde manier als we elke kenmerkmatrix doorgeven. Hier hebben we het als voorbeeld gebruikt = [[3 5 4 2] [2 3 5 4]]

sample = [[3 5 4 2] [2 3 5 4]] preds = log_reg.predict(sample) pred_species = [iris.target_names[p] for p in preds] print('Predictions:' pred_species) 

Uitgang: 

Voorspellingen: [np.str_('virginica') np.str_('virginica')]

Kenmerken van Scikit-leren

Scikit-learn wordt gebruikt omdat het het bouwen van machine learning-modellen eenvoudig en efficiënt maakt. Hier zijn enkele belangrijke redenen:

1. Kant-en-klare hulpmiddelen : Het biedt ingebouwde functies voor algemene taken, zoals het voorbewerken van gegevens, trainingsmodellen en het maken van voorspellingen. Dit bespaart tijd omdat het niet nodig is om algoritmen helemaal opnieuw te coderen.
2. Eenvoudige modelevaluatie : Met tools als kruisvalidatie en prestatiestatistieken helpt het om te meten hoe goed ons model werkt en om verbeterpunten te identificeren.
3. Brede ondersteuning voor algoritmen : Het biedt veel populaire machine learning-algoritmen, waaronder classificatieregressie en clustering, wat ons de flexibiliteit geeft om het juiste model voor ons probleem te kiezen.
4. Soepele integratie : Gebouwd bovenop belangrijke Python-bibliotheken zoals NumPy en SciPy, zodat het past in onze bestaande data-analyseworkflow.
5. Eenvoudige en consistente interface : Dezelfde eenvoudige syntaxis werkt in verschillende modellen en maakt het gemakkelijker om algoritmen te leren en te schakelen.
6. Modelafstemming gemakkelijk gemaakt : Hulpmiddelen zoals rasterzoeken helpen ons de instellingen van ons model te verfijnen om de nauwkeurigheid te verbeteren zonder extra gedoe.

Voordelen van het gebruik van Scikit-learn

• Gebruiksvriendelijk : De consistente en eenvoudige interface van Scikit-learn maakt het toegankelijk voor beginners en het beste voor experts.
• Tijdbesparend: Vooraf gebouwde tools en algoritmen verkorten de ontwikkeltijd, waardoor we ons meer kunnen concentreren op het oplossen van problemen dan op het coderen van details.
• Betere modelprestaties : Eenvoudig te gebruiken afstemmings- en evaluatietools helpen bij het verbeteren van de nauwkeurigheid en betrouwbaarheid van modellen.
• Flexibel en schaalbaar : Ondersteunt een breed scala aan algoritmen en kan soepel worden geïntegreerd met andere Python-bibliotheken, waardoor het geschikt is voor projecten van elke omvang.
• Sterke steun van de gemeenschap : Een grote actieve community zorgt voor regelmatige updates, uitgebreide documentatie en voldoende bronnen om te helpen als we vastlopen.