Maskininlärningshandledning med Scikit-lär

I den här lektionen om maskininlärning med scikit-lärande kommer vi att lära oss olika aspekter av detta utmärkta Python-paket som gör det möjligt för oss att tillämpa enkla och komplexa maskininlärningsfunktioner på en mängd olika data tillsammans med funktioner för att testa hypotesen.

Scikit-Learn-paketet innehåller enkla och effektiva verktyg för att tillämpa datautvinning och dataanalys på datamängder och dessa algoritmer är tillgängliga för användning i olika sammanhang. Det är ett öppen källkodspaket tillgängligt under en BSD-licens, vilket innebär att vi kan använda detta bibliotek även kommersiellt. Den är byggd ovanpå matplotlib, NumPy och SciPy så den är mångsidig i naturen. Vi kommer att använda Anaconda med Jupyter-anteckningsboken för att presentera exempel i den här lektionen.

Vad scikit-learning ger?

Scikit-learning-biblioteket fokuserar helt på datamodellering. Observera att det inte finns några större funktioner i scikit-lärandet när det gäller att ladda, manipulera och sammanfatta data. Här är några av de populära modellerna som scikit-learning ger oss:

Kluster för att gruppera märkta data
Datamängder att tillhandahålla testdatauppsättningar och undersöka modellbeteenden
Korsvalidering att uppskatta prestanda för övervakade modeller på osedda data
Ensemble metoder för att kombinera förutsägelser från flera övervakade modeller
Särdragsextraktion för att definiera attribut i bild- och textdata

Installera Python scikit-learn

Bara en anteckning innan vi startar installationsprocessen använder vi en virtuell miljö för den här lektionen som vi gjorde med följande kommando:

python -m virtualenv scikit
källa scikit / bin / aktivera

När den virtuella miljön är aktiv kan vi installera pandabiblioteket i det virtuella env så att exempel vi skapar nästa kan köras:

pip installera scikit-learn

Eller så kan vi använda Conda för att installera detta paket med följande kommando:

conda installera scikit-lär

Vi ser något liknande när vi utför ovanstående kommando:

När installationen har slutförts med Conda kommer vi att kunna använda paketet i våra Python-skript som:

importera sklearn

Låt oss börja använda scikit-learning i våra skript för att utveckla fantastiska maskininlärningsalgoritmer.

Importera datamängder

En av de coolaste sakerna med scikit-learning är att den levereras förinstallerad med exempeluppsättningar som det är lätt att komma igång snabbt. Datauppsättningarna är iris och siffror datauppsättningar för klassificering och boston huspriser dataset för regressionstekniker. I det här avsnittet kommer vi att titta på hur man laddar och börjar använda irisdatauppsättningen.

För att importera en datauppsättning måste vi först importera rätt modul följt av att spärra datauppsättningen:

från sklearn importera datamängder
iris = datamängder.load_iris ()
siffror = datamängder.ladda siffror ()
siffror.data

När vi har kört kodavsnittet ovan ser vi följande utdata:

Hela utdata tas bort för att göra det kortare. Detta är den datamängd som vi huvudsakligen kommer att använda i den här lektionen men de flesta begreppen kan tillämpas på i allmänhet alla datamängder.

Bara ett roligt faktum att veta att det finns flera moduler i scikit ekosystem, varav en är lära sig används för maskininlärningsalgoritmer. Se den här sidan för många andra moduler närvarande.

Utforska datauppsättningen

Nu när vi har importerat den angivna siffrans dataset till vårt skript bör vi börja samla grundläggande information om datasetet och det är vad vi kommer att göra här. Här är de grundläggande sakerna du bör utforska när du letar efter information om en dataset:

Målvärdena eller etiketterna
Beskrivningsattributet
Nycklarna som finns i den angivna datamängden

Låt oss skriva ett kort kodavsnitt för att extrahera ovanstående tre information från vår dataset:

skriva ut ('Target:', siffror.mål)
skriva ut ('Tangenter:', siffror.nycklar ())
print ('Beskrivning:', siffror.BESKRIVNING)

När vi har kört kodavsnittet ovan ser vi följande utdata:

Observera att de variabla siffrorna inte är enkla. När vi skrev ut siffrans dataset innehöll den faktiskt numpy arrays. Vi får se hur vi kan komma åt dessa matriser. Observera de nycklar som finns tillgängliga i siffrorna som vi skrev ut i det senaste kodavsnittet.

Vi börjar med att få formen på arraydata, vilket är de rader och kolumner som arrayen har. För detta måste vi först få de faktiska uppgifterna och sedan få formen:

digits_set = siffror.data
skriva ut (siffror_uppsättning.form)

När vi har kört kodavsnittet ovan ser vi följande utdata:

Detta innebär att vi har 1797 prover i vår dataset tillsammans med 64 datafunktioner (eller kolumner). Vi har också några måletiketter som vi kommer att visualisera här med hjälp av matplotlib. Här är ett kodavsnitt som hjälper oss att göra det:

importera matplotlib.pyplot som plt
# Slå ihop bilderna och måletiketterna som en lista
images_and_labels = lista (zip (siffror.bilder, siffror.mål))
för index, (bild, etikett) i enumerate (images_and_labels [: 8]):
# initiera en delplot på 2X4 i i + 1: e position
plt.delplan (2, 4, index + 1)
# Du behöver inte plotta några axlar
plt.axel ('av')
# Visa bilder i alla delplottar
plt.imshow (bild, cmap = plt.centimeter.grå_r, interpolation = 'närmast')
# Lägg till en titel till varje delplott
plt.titel ('Träning:' + str (etikett))
plt.show()

När vi har kört kodavsnittet ovan ser vi följande utdata:

Lägg märke till hur vi zippade de två NumPy-matriserna tillsammans innan vi plottade dem på ett rutnät 4 gånger 2 utan någon axelinformation. Nu är vi säkra på den information vi har om den dataset vi arbetar med.

Nu när vi vet att vi har 64 datafunktioner (som förresten är många funktioner) är det utmanande att visualisera de faktiska uppgifterna. Vi har dock en lösning på detta.

Principal Component Analysis (PCA)

Detta är inte en handledning om PCA, men låt oss ge en liten uppfattning om vad det är. Eftersom vi vet att för att minska antalet funktioner från en dataset har vi två tekniker:

Eliminering av funktioner
Särdragsextraktion

Medan den första tekniken står inför frågan om förlorade datafunktioner, även om de kan ha varit viktiga, lider den andra tekniken inte av problemet som med hjälp av PCA, vi konstruerar nya datafunktioner (mindre i antal) där vi kombinerar mata in variabler på ett sådant sätt att vi kan utesluta de "minst viktiga" variablerna samtidigt som vi behåller de mest värdefulla delarna av alla variablerna.

Som förväntat, PCA hjälper oss att minska datadimensionaliteten vilket är ett direkt resultat av att beskriva ett objekt med många datafunktioner. Inte bara siffror utan många andra praktiska datamängder har ett stort antal funktioner som inkluderar finansiella institutionella data, väder- och ekonomidata för en region etc. När vi utför PCA på siffrans dataset, vårt mål är att hitta bara två funktioner så att de har de flesta egenskaperna i datasetet.

Låt oss skriva ett enkelt kodavsnitt för att tillämpa PCA på siffrorna för att få vår linjära modell av bara två funktioner:

från sklearn.nedbrytning import PCA
feature_pca = PCA (n_components = 2)
reduced_data_random = feature_pca.fit_transform (siffror.data)
modell_pca = PCA (n_komponenter = 2)
reducerad_data_pca = modell_pca.fit_transform (siffror.data)
reducerad_data_pca.form
skriva ut (reducerad_data_ slumpmässig)
skriv ut (reducerad_data_pca)

När vi har kört kodavsnittet ovan ser vi följande utdata:

[[-1.2594655 21.27488324]
[7.95762224 -20.76873116]
[6.99192123 -9.95598191]
..
[10.8012644 -6.96019661]
[-4.87210598 12.42397516]
[-0.34441647 6.36562581]]
[[-1.25946526 21.27487934]
[7.95761543 -20.76870705]
[6.99191947 -9.9559785]
..
[10.80128422 -6.96025542]
[-4.87210144 12.42396098]
[-0.3443928 6.36555416]]

I ovanstående kod nämner vi att vi bara behöver två funktioner för datasetet.

Nu när vi har god kunskap om vår dataset kan vi bestämma vilken typ av maskininlärningsalgoritmer vi kan använda på den. Att känna till en dataset är viktigt eftersom det är så vi kan bestämma vilken information som kan extraheras ur den och med vilka algoritmer. Det hjälper oss också att testa den hypotes vi fastställer samtidigt som vi förutsäger framtida värden.

Tillämpa k-betyder kluster

K-betyder klusteralgoritmen är en av de enklaste klustringsalgoritmerna för inlärning utan tillsyn. I det här klustret har vi ett slumpmässigt antal kluster och vi klassificerar våra datapunkter i ett av dessa kluster. K-medelalgoritmen hittar närmaste kluster för var och en av den givna datapunkten och tilldelar den datapunkten till det klustret.

När klustringen är klar beräknas klustrets centrum igen, datapunkterna tilldelas nya kluster om det finns några ändringar. Denna process upprepas tills datapunkterna slutar förändras där kluster för att uppnå stabilitet.

Låt oss helt enkelt använda den här algoritmen utan någon förbehandling av data. För denna strategi kommer kodavsnittet att vara ganska enkelt:

från sklearn importkluster
k = 3
k_means = kluster.KMeans (k)
# fit data
k_medlar.passform (siffror.data)
# utskriftsresultat
skriva ut (k_medlar.etiketter _ [:: 10])
skriva ut (siffror.mål [:: 10])

När vi har kört kodavsnittet ovan ser vi följande utdata:

I ovanstående utdata kan vi se olika kluster tillhandahålls till var och en av datapunkterna.

Slutsats

I den här lektionen tittade vi på ett utmärkt Machine Learning-bibliotek, scikit-learning. Vi lärde oss att det finns många andra moduler tillgängliga i scikit-familjen och vi använde enkel k-medelalgoritm på den angivna datasetet. Det finns många fler algoritmer som kan tillämpas på datasetet förutom k-betyder klustring som vi använde i den här lektionen, vi uppmuntrar dig att göra det och dela dina resultat.

Dela din feedback om lektionen på Twitter med @sbmaggarwal och @LinuxHint.