Scikit-learn este o bibliotecă Python open-source care simplifică procesul de construire a modelelor de învățare automată. Oferă o interfață curată și consecventă care îi ajută atât pe începători, cât și pe utilizatorii experimentați să lucreze eficient.

• Acceptă sarcini precum gruparea regresiei clasificării și preprocesarea
• Face construirea modelelor rapidă și fiabilă
• Oferă instrumente gata de utilizare pentru instruire și evaluare
• Reduce complexitatea evitând implementarea manuală a algoritmilor

Instalarea și utilizarea Scikit-learn

Înainte de a începe să construim modele, trebuie să instalăm Scikit-învață. Necesită Python 3.8 sau mai nou și depinde de două biblioteci importante: NumPy şi SciPy. Asigurați-vă că acestea sunt instalate mai întâi.

Pentru a instala Scikit-learn, rulați următoarea comandă:

converti șirul în data

pip install -U scikit-learn

Aceasta va descărca și instala cea mai recentă versiune de Scikit-learn împreună cu dependențele sale. Să vedem diferiți pași implicați în procesul de construire a modelului folosind biblioteca Scikit-learn.

Pasul 1: Încărcarea unui set de date

Un set de date este format din:

• Caracteristici (X): Variabile de intrare care descriu datele
• Țintă (y): Valoarea pe care vrem să o prezicem

Scikit-learn oferă seturi de date încorporate precum Iris Digits și Boston Housing. Folosind setul de date Iris:

• load_iris() încarcă datele
• X stochează datele caracteristicilor
• y stochează etichete țintă
• feature_names și target_names oferă nume descriptive

Putem inspecta primele rânduri pentru a înțelege structura. Pentru seturile de date personalizate, Pandas este folosit în mod obișnuit pentru a încărca fișiere externe, cum ar fi CSV-uri.

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

Ieșire: 

Uneori trebuie să lucrăm la propriile noastre date personalizate, apoi încărcăm un set de date extern. Pentru aceasta putem folosi biblioteca panda pentru încărcarea și manipularea ușoară a seturilor de date.

Pentru aceasta, puteți consulta articolul nostru despre Cum se importă fișierul csv în panda ?

Pasul 2: Împărțirea setului de date

Pentru a evalua corect un model, împărțim datele în:

• Set de antrenament: Folosit pentru a antrena modelul
• Set de testare: Folosit pentru a evalua cât de bine se generalizează modelul

Folosind train_test_split, împărțim setul de date Iris astfel încât 60% să fie pentru antrenament și 40% pentru testare (test_size=0,4). random_state=1 asigură reproductibilitatea.

mouse și tipuri de mouse

După împărțire obținem:

• X_train y_train -> Date de antrenament
• X_test y_test -> Date de testare

Verificarea formelor asigură că datele sunt împărțite corect.

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) 

Acum să verificăm Forme a datelor împărțite pentru a se asigura că ambele seturi au proporții corecte de date, evitând orice potențiale erori în evaluarea sau instruirea modelului.

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) 

Ieșire:

Pasul 3: Gestionarea datelor categorice

Algoritmii de învățare automată funcționează cu intrări numerice, astfel încât datele categorice (text) trebuie convertite în numere. Dacă nu sunt codificate corect, modelele pot interpreta greșit categoriile. Scikit-learn oferă mai multe metode de codare:

care este dimensiunea ecranului monitorului meu

1. Codificarea etichetei : convertește fiecare categorie într-un număr întreg unic. De exemplu, într-o coloană cu categorii precum „pisica”, „câine” și „pasăre”, le-ar converti la 0 1 și, respectiv, 2. Această metodă funcționează bine atunci când categoriile au o ordine semnificativă, cum ar fi Scăzut, Mediu, și Ridicat.

• LabelEncoder(): Este inițializat pentru a crea un obiect codificator care va converti valorile categorice în etichete numerice.
• fit_transform(): Această metodă potrivește mai întâi codificatorul la datele categoriale și apoi transformă categoriile în etichete numerice corespunzătoare.

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) 

Ieșire:

Caracteristica codificată: [1 2 2 1 0]

2. Codificare One-Hot : One-Hot Encoding creează coloane binare separate pentru fiecare categorie. Acest lucru este util atunci când categoriile nu au nicio ordine naturală. Exemplu: pisică câine pasăre -> 3 coloane noi (pisică/câine/pasăre) cu 1 și 0.

• Intrarea trebuie remodelată într-o matrice 2D
• OneHotEncoder(sparse_output=False) generează coloane binare

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) 

Ieșire:

Pe lângă codificarea etichetelor și codificarea One-Hot, există și alte tehnici precum Codificare medie .

Pasul 4: Antrenarea modelului

Acum că datele noastre sunt gata, este timpul să antrenăm un model de învățare automată. Scikit-learn are mulți algoritmi cu o interfață consistentă pentru predicția și evaluarea antrenamentului. Aici vom folosi Regresia logistică ca exemplu.

Nota : Nu vom intra în detalii despre cum funcționează algoritmul, deoarece suntem interesați doar să înțelegem implementarea lui. 

• log_reg = LogisticRegression(max_iter=200): Crearea unui obiect clasificator de regresie logistică.
• log_reg.fit(X_train y_train): Folosind asta modelul de regresie logistică ajustează parametrii modelului pentru a se potrivi cel mai bine cu datele.

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

Pasul 5: Faceți predicții

Odată antrenați, folosim modelul pentru a face predicții asupra datelor de test X_test apelând metoda predict. Aceasta returnează etichetele prezise y_pred.

• log_reg.predict: Utilizează un model de regresie logistică antrenat pentru a prezice etichetele pentru datele de testare X_test.

y_pred = log_reg.predict(X_test) 

Pasul 6: Evaluarea preciziei modelului

Verificați cât de bine funcționează modelul nostru comparând y_test și y_pred. Aici folosim metoda accuracy_score a modulului de metrici.

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

Ieșire:

Precizia modelului de regresie logistică: 0,96666666666666667

Acum dorim ca modelul nostru să facă predicții pe noi date de eșantion. Apoi, intrarea eșantionului poate fi pur și simplu transmisă în același mod în care trecem orice matrice de caracteristici. Aici l-am folosit ca probă = [[3 5 4 2] [2 3 5 4]]

sonu nigam

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) 

Ieșire: 

Predicții: [np.str_('virginica') np.str_('virginica')]

Caracteristicile Scikit-learn

Scikit-learn este folosit deoarece face construirea modelelor de învățare automată simplă și eficientă. Iată câteva motive importante:

1. Instrumente gata de utilizare : oferă funcții încorporate pentru sarcini obișnuite, cum ar fi modelele de antrenament pentru preprocesarea datelor și realizarea de predicții. Acest lucru economisește timp prin evitarea necesității de a codifica algoritmii de la zero.
2. Evaluare ușoară a modelului : Cu instrumente precum validarea încrucișată și valorile de performanță, ajută la măsurarea cât de bine funcționează modelul nostru și la identificarea zonelor de îmbunătățire.
3. Suport larg de algoritm : Oferă mulți algoritmi populari de învățare automată, inclusiv regresia clasificării și gruparea, ceea ce ne oferă flexibilitate pentru a alege modelul potrivit pentru problema noastră.
4. Integrare lină : Construit pe baza unor biblioteci Python importante precum NumPy și SciPy, astfel încât să se încadreze în fluxul nostru de lucru existent de analiză a datelor.
5. Interfață simplă și consistentă : Aceeași sintaxă simplă funcționează în diferite modele, facilitând învățarea și comutarea între algoritmi.
6. Reglajul modelului este ușor : Instrumente precum căutarea în grilă ne ajută să reglam setările modelului nostru pentru a îmbunătăți acuratețea fără probleme suplimentare.

Beneficiile utilizării Scikit-learn

• Ușor de utilizat : Interfața consecventă și simplă a lui Scikit-learn o face accesibilă pentru începători și cea mai bună pentru experți.
• Economie de timp: Instrumentele și algoritmii preconstruiți reduc timpul de dezvoltare, ceea ce ne permite să ne concentrăm mai mult pe rezolvarea problemelor decât pe detaliile de codare.
• Performanță mai bună a modelului : Instrumentele de reglare și evaluare ușor de utilizat ajută la îmbunătățirea preciziei și fiabilității modelului.
• Flexibil și scalabil : Acceptă o gamă largă de algoritmi și se integrează fără probleme cu alte biblioteci Python, contribuind la a-l face potrivit pentru proiecte de orice dimensiune.
• Sprijin puternic al comunității : O comunitate mare activă asigură actualizări regulate, documentație extinsă și o mulțime de resurse pentru a ne ajuta atunci când rămânem blocați.