Scikit-learn är ett Python-bibliotek med öppen källkod som förenklar processen att bygga maskininlärningsmodeller. Det erbjuder ett rent och konsekvent gränssnitt som hjälper både nybörjare och erfarna användare att arbeta effektivt.

• Stöder uppgifter som klassificeringsregressionsklustring och förbearbetning
• Gör modellbyggandet snabbt och pålitligt
• Ger färdiga verktyg för utbildning och utvärdering
• Minskar komplexiteten genom att undvika manuell implementering av algoritmer

Installera och använda Scikit-learn

Innan vi börjar bygga modeller måste vi installera Scikit-lär dig. Det kräver Python 3.8 eller senare och beror på två viktiga bibliotek: NumPy och SciPy. Se till att dessa installeras först.

För att installera Scikit-learn kör följande kommando:

pip install -U scikit-learn

Detta kommer att ladda ner och installera den senaste versionen av Scikit-learn tillsammans med dess beroenden. Låt oss se olika steg involverade i processen att bygga modell med hjälp av Scikit-learn-biblioteket.

Steg 1: Ladda en datamängd

En datauppsättning består av:

• Funktioner (X): Indatavariabler som beskriver data
• Mål (y): Värdet vi vill förutsäga

Scikit-learn tillhandahåller inbyggda datauppsättningar som Iris Digits och Boston Housing. Använda Iris dataset:

• load_iris() laddar data
• X lagrar funktionsdata
• y lagrar måletiketter
• feature_names och target_names ger beskrivande namn

Vi kan inspektera de första raderna för att förstå strukturen. För anpassade datauppsättningar Pandas används vanligtvis för att ladda externa filer 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: 

Ibland behöver vi arbeta med vår egen anpassade data då vi laddar en extern datauppsättning. För detta kan vi använda pandas bibliotek för enkel laddning och hantering av datauppsättningar.

För detta kan du hänvisa till vår artikel om Hur man importerar csv-fil i pandas ?

mylivericket

Steg 2: Dela upp datamängden

För att utvärdera en modell rättvist delar vi upp data i:

• Träningsset: Används för att träna modellen
• Testset: Används för att utvärdera hur väl modellen generaliserar

Med train_test_split delar vi upp Iris-datauppsättningen så att 60 % är för träning och 40 % för testning (test_size=0,4). random_state=1 säkerställer reproducerbarhet.

Efter splittringen får vi:

• X_train y_train -> Träningsdata
• X_test y_test -> Testa data

Att kontrollera formerna säkerställer att data delas korrekt.

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) 

Låt oss nu kontrollera Former av de delade data för att säkerställa att båda uppsättningarna har korrekta proportioner av data och undviker eventuella fel i modellutvärdering eller utbildning.

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:

Steg 3: Hantera kategoriska data

Maskininlärningsalgoritmer fungerar med numeriska indata så kategorisk (text)data måste omvandlas till siffror. Om de inte är korrekt kodade kan modeller misstolka kategorier. Scikit-learn tillhandahåller flera kodningsmetoder:

1. Etikettkodning : Den konverterar varje kategori till ett unikt heltal. Till exempel i en kolumn med kategorier som 'katt' 'hund' och 'fågel' skulle det konvertera dem till 0 1 respektive 2. Denna metod fungerar bra när kategorierna har en meningsfull ordning som Låg Medium och Hög.

• LabelEncoder(): Det initieras för att skapa ett kodningsobjekt som konverterar kategoriska värden till numeriska etiketter.
• fit_transform(): Denna metod anpassar först kodaren till kategoridata och omvandlar sedan kategorierna till motsvarande numeriska 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:

Kodad funktion: [1 2 2 1 0]

2. One-Hot Encoding : One-Hot Encoding skapar separata binära kolumner för varje kategori. Detta är användbart när kategorier inte har någon naturlig ordning. Exempel: katthund fågel -> 3 nya kolumner (katt/hund/fågel) med 1:or och 0:or.

• Indata måste omformas till en 2D-array
• OneHotEncoder(sparse_output=False) genererar binära kolumner

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:

Förutom Label Encoding och One-Hot Encoding finns det andra tekniker som Genomsnittlig kodning .

Steg 4: Utbilda modellen

Nu när vår data är klar är det dags att träna en maskininlärningsmodell. Scikit-learn har många algoritmer med ett konsekvent gränssnitt för träningsförutsägelse och utvärdering. Här kommer vi att använda Logistisk regression som ett exempel.

Notera : Vi kommer inte att gå in på detaljerna om hur algoritmen fungerar eftersom vi bara är intresserade av att förstå dess implementering. 

• log_reg = LogisticRegression(max_iter=200): Skapa ett logistiskt regressionsklassificerobjekt.
• log_reg.fit(X_train y_train): Använder detta den logistiska regressionsmodellen justerar modellens parametrar för att bäst passa data.

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

Steg 5: Gör förutsägelser

När vi väl har tränats använder vi modellen för att göra förutsägelser på testdatan X_test genom att anropa prediktionsmetoden. Detta returnerar förutspådda etiketter y_pred.

• log_reg.predict: Den använder en tränad logistisk regressionsmodell för att förutsäga etiketter för testdata X_test.

y_pred = log_reg.predict(X_test) 

Steg 6: Utvärdera modellens noggrannhet

Kontrollera hur bra vår modell presterar genom att jämföra y_test och y_pred. Här använder vi mätmodulens metod accuracy_score.

lista metoder java

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

Produktion:

Logistisk regressionsmodell noggrannhet: 0,9666666666666667

Nu vill vi att vår modell ska göra förutsägelser om nya provdata. Sedan kan provinmatningen helt enkelt skickas på samma sätt som vi skickar vilken funktionsmatris som helst. Här använde vi det som exempel = [[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: 

Förutsägelser: [np.str_('virginica') np.str_('virginica')]

Funktioner i Scikit-learn

Scikit-learn används för att det gör det enkelt och effektivt att bygga modeller för maskininlärning. Här är några viktiga skäl:

1. Redo att använda verktyg : Den tillhandahåller inbyggda funktioner för vanliga uppgifter som träningsmodeller för dataförbearbetning och att göra förutsägelser. Detta sparar tid genom att undvika behovet av att koda algoritmer från början.
2. Enkel modellutvärdering : Med verktyg som korsvalidering och prestationsmått hjälper det att mäta hur väl vår modell fungerar och identifiera områden för förbättringar.
3. Brett algoritmstöd : Den erbjuder många populära maskininlärningsalgoritmer inklusive klassificeringsregression och klustring som ger oss flexibilitet att välja rätt modell för vårt problem.
4. Smidig integration : Byggd ovanpå viktiga Python-bibliotek som NumPy och SciPy så att det passar in i vårt befintliga arbetsflöde för dataanalys.
5. Enkelt och konsekvent gränssnitt : Samma enkla syntax fungerar över olika modeller hjälper till att göra det lättare att lära sig och växla mellan algoritmer.
6. Modellinställning på ett enkelt sätt : Verktyg som rutnätssökning hjälper oss att finjustera vår modells inställningar för att förbättra noggrannheten utan extra krångel.

Fördelar med att använda Scikit-learn

• Användarvänlig : Scikit-learns konsekventa och enkla gränssnitt gör det tillgängligt för nybörjare och bäst för experter.
• Tidsbesparande: Förbyggda verktyg och algoritmer minskar utvecklingstiden vilket gör att vi kan fokusera mer på att lösa problem än att koda detaljer.
• Bättre modellprestanda : Lättanvända inställnings- och utvärderingsverktyg hjälper till att förbättra modellens noggrannhet och tillförlitlighet.
• Flexibel och skalbar : Stöder ett brett utbud av algoritmer och integreras smidigt med andra Python-bibliotek hjälper till att göra det lämpligt för projekt av alla storlekar.
• Starkt samhällsstöd : En stor aktiv community säkerställer regelbundna uppdateringar omfattande dokumentation och massor av resurser för att hjälpa när vi fastnar.