Scikit-learn er et open source Python-bibliotek, der forenkler processen med at bygge maskinlæringsmodeller. Det tilbyder en ren og ensartet grænseflade, der hjælper både begyndere og erfarne brugere med at arbejde effektivt.

• Understøtter opgaver som klassifikationsregressionsklyngning og forbehandling
• Gør modelbygning hurtig og pålidelig
• Giver klar til brug værktøjer til træning og evaluering
• Reducerer kompleksiteten ved at undgå manuel implementering af algoritmer

Installation og brug af Scikit-learn

Før vi begynder at bygge modeller, skal vi installere Scikit-lær. Det kræver Python 3.8 eller nyere og afhænger af to vigtige biblioteker: NumPy og SciPy. Sørg for, at disse er installeret først.

der skabte skolen

For at installere Scikit-learn skal du køre følgende kommando:

pip install -U scikit-learn

Dette vil downloade og installere den seneste version af Scikit-learn sammen med dens afhængigheder. Lad os se forskellige trin involveret i processen med at bygge model ved hjælp af Scikit-learn-biblioteket.

Trin 1: Indlæsning af et datasæt

Et datasæt består af:

• Funktioner (X): Inputvariabler, der beskriver dataene
• Mål (y): Den værdi, vi ønsker at forudsige

Scikit-learn leverer indbyggede datasæt som Iris Digits og Boston Housing. Brug af Iris-datasættet:

np.hvor

• load_iris() indlæser dataene
• X gemmer funktionsdata
• y gemmer måletiketter
• feature_names og target_names giver beskrivende navne

Vi kan inspicere de første par rækker for at forstå strukturen. Til brugerdefinerede datasæt bruges Pandas almindeligvis til at indlæse eksterne filer såsom CSV'er.

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]) 

Produktion: 

Nogle gange skal vi arbejde på vores egne brugerdefinerede data, så indlæser vi et eksternt datasæt. Til dette kan vi bruge pandas bibliotek for nem indlæsning og manipulering af datasæt.

For dette kan du henvise til vores artikel om Sådan importeres csv-fil i pandas ?

Trin 2: Opdeling af datasættet

For at evaluere en model retfærdigt opdeler vi data i:

• Træningssæt: Bruges til at træne modellen
• Testsæt: Bruges til at evaluere, hvor godt modellen generaliserer

Ved at bruge train_test_split opdeler vi Iris-datasættet, så 60% er til træning og 40% til test (test_size=0,4). random_state=1 sikrer reproducerbarhed.

Efter opdeling får vi:

• X_train y_train -> Træningsdata
• X_test y_test -> Test af data

Kontrol af formerne sikrer, at dataene er opdelt korrekt.

forskel på en tiger og en løve

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) 

Lad os nu tjekke Former af de opdelte data for at sikre, at begge sæt har korrekte dataproportioner og undgår potentielle fejl i modelevaluering eller træning.

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) 

Produktion:

Trin 3: Håndtering af kategoriske data

Maskinlæringsalgoritmer arbejder med numeriske input, så kategoriske (tekst)data skal konverteres til tal. Hvis de ikke er kodet korrekt, kan modeller misfortolke kategorier. Scikit-learn tilbyder flere kodningsmetoder:

1. Etiketkodning : Den konverterer hver kategori til et unikt heltal. For eksempel i en kolonne med kategorier som 'kat' 'hund' og 'fugl' ville det konvertere dem til henholdsvis 0 1 og 2. Denne metode fungerer godt, når kategorierne har en meningsfuld rækkefølge såsom Lav Middel og Høj.

• LabelEncoder(): Det initialiseres til at skabe et indkoderobjekt, der vil konvertere kategoriske værdier til numeriske etiketter.
• fit_transform(): Denne metode tilpasser først indkoderen til de kategoriske data og transformerer derefter kategorierne til tilsvarende numeriske etiketter.

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) 

Produktion:

Kodet funktion: [1 2 2 1 0]

2. One-Hot-kodning : One-Hot Encoding opretter separate binære kolonner for hver kategori. Dette er nyttigt, når kategorier ikke har nogen naturlig rækkefølge. Eksempel: kat hund fugl -> 3 nye kolonner (kat/hund/fugl) med 1'ere og 0'ere.

• Input skal omformes til et 2D-array
• OneHotEncoder(sparse_output=False) genererer binære kolonner

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) 

Produktion:

fil åben i java

Udover Label Encoding og One-Hot Encoding er der andre teknikker som f.eks Gennemsnitlig kodning .

Trin 4: Træning af modellen

Nu hvor vores data er klar, er det tid til at træne en maskinlæringsmodel. Scikit-learn har mange algoritmer med en ensartet grænseflade til træningsforudsigelse og evaluering. Her vil vi bruge Logistisk regression som eksempel.

Note : Vi vil ikke gå i detaljer om, hvordan algoritmen fungerer, da vi kun er interesseret i at forstå dens implementering. 

• log_reg = Logistisk regression(max_iter=200): Oprettelse af et logistisk regressionsklassifikatorobjekt.
• log_reg.fit(X_train y_train): Bruger dette den logistiske regressionsmodel justerer modellens parametre, så de passer bedst til dataene.

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

Trin 5: Lav forudsigelser

Når vi er trænet, bruger vi modellen til at lave forudsigelser på testdataene X_test ved at kalde forudsigelsesmetoden. Dette returnerer forudsagte etiketter y_pred.

• log_reg.predict: Den bruger trænet logistisk regressionsmodel til at forudsige etiketter for testdataene X_test.

y_pred = log_reg.predict(X_test) 

Trin 6: Evaluering af modellens nøjagtighed

Tjek hvor godt vores model klarer sig ved at sammenligne y_test og y_pred. Her bruger vi metric-modulets metode accuracy_score.

hvis andet hvis andet java

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

Produktion:

Logistisk regressionsmodels nøjagtighed: 0,9666666666666667

Nu vil vi have vores model til at lave forudsigelser på nye prøvedata. Så kan prøveinputtet simpelthen videregives på samme måde, som vi passerer en hvilken som helst funktionsmatrix. Her brugte vi det som eksempel = [[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) 

Produktion: 

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

Funktioner i Scikit-learn

Scikit-learn bruges, fordi det gør opbygning af maskinlæringsmodeller ligetil og effektiv. Her er nogle vigtige grunde:

1. Klar-til-brug værktøjer : Det giver indbyggede funktioner til almindelige opgaver som træningsmodeller til dataforbehandling og forudsigelser. Dette sparer tid ved at undgå behovet for at kode algoritmer fra bunden.
2. Nem modelvurdering : Med værktøjer som krydsvalidering og præstationsmålinger hjælper det med at måle, hvor godt vores model fungerer, og identificere områder for forbedring.
3. Bred algoritmeunderstøttelse : Det tilbyder mange populære maskinlæringsalgoritmer, herunder klassifikationsregression og clustering, som giver os fleksibilitet til at vælge den rigtige model til vores problem.
4. Glat integration : Bygget oven på vigtige Python-biblioteker som NumPy og SciPy, så det passer ind i vores eksisterende dataanalyse-workflow.
5. Enkel og ensartet grænseflade : Den samme ligetil syntaks fungerer på tværs af forskellige modeller hjælper med at gøre det nemmere at lære og skifte mellem algoritmer.
6. Modeltuning gjort nemt : Værktøjer som gittersøgning hjælper os med at finjustere vores models indstillinger for at forbedre nøjagtigheden uden ekstra besvær.

Fordele ved at bruge Scikit-learn

• Brugervenlig : Scikit-learns konsekvente og enkle grænseflade gør den tilgængelig for begyndere og bedst for eksperter.
• Tidsbesparende: Forudbyggede værktøjer og algoritmer reducerer udviklingstiden, hvilket giver os mulighed for at fokusere mere på at løse problemer end at kode detaljer.
• Bedre modelydelse : Brugervenlige tuning- og evalueringsværktøjer hjælper med at forbedre modellens nøjagtighed og pålidelighed.
• Fleksibel og skalerbar : Understøtter en bred vifte af algoritmer og integreres problemfrit med andre Python-biblioteker, hvilket hjælper med at gøre det velegnet til projekter af enhver størrelse.
• Stærk fællesskabsstøtte : Et stort aktivt fællesskab sikrer regelmæssige opdateringer omfattende dokumentation og masser af ressourcer til at hjælpe, når vi går i stå.