Scikit lär - Machine Learning med Python

I den här bloggen kommer vi att diskutera Scikit-lärande i python. Innan man pratar om Scikit-lärande måste man förstå begreppet maskininlärningoch måste veta hur man använder . Med maskininlärning behöver du inte samla in dina insikter manuellt. Du behöver bara en algoritm så gör maskinen resten för dig! Är det inte spännande? Scikit lär är en av attraktionerna där vi kan implementera maskininlärning med hjälp av Python. denär ett gratis maskininlärningsbibliotek som innehåller enkla och effektiva verktyg för dataanalys och gruvdrift.Jag tar dig igenom följande ämnen, som kommer att fungera som grundläggande för de kommande bloggarna:

• • Vad är maskininlärning ?
  • Översikt över Scikit Learn
  • Installation
  • Användningsfall -Logistisk tillbakagång

Vad är maskininlärning?

Maskininlärning är en typ av artificiell intelligens som gör det möjligt för programvaror att lära av data och bli mer exakta i att förutsäga resultat utan mänsklig inblandning. Men hur händer det? För det måste maskinen tränas på vissa data och baserat på det kommer den att upptäcka ett mönster för att skapa en modell.Denna process för att få kunskap från data och ge kraftfull insikt handlar om maskininlärning. Se bilden nedan för att få en bättre förståelse för hur den fungerar:

Med hjälp av data lär sig systemet en algoritm och använder den sedan för att bygga en förutsägbar modell. Senare justerar vi modellen eller förbättrar vi modellens noggrannhet med hjälp av feedbackdata. Med hjälp av denna feedbackdata ställer vi in ​​modellen och förutsäger åtgärder på den nya datamängden. Vi skadiskuterar en användningsfall av en av algoritmens tillvägagångssätt där vi kommer att träna och testa data som hjälper dig att ge en bättre uppfattning om det kommer att passa just ditt specifika problem eller inte.

Därefter finns det tre typer av maskininlärning:

• • Övervakat lärande : Detta är en process där en algoritm lär sig från träningsdatasetet. Övervakad inlärning är där du genererar en kartläggningsfunktion mellan ingångsvariabeln (X) och en utgångsvariabel (Y) och du använder en algoritm för att generera en funktion mellan dem. Det är också känt som prediktiv modellering som refererar till en process för att göra förutsägelser med hjälp av data. Några av algoritmerna inkluderar linjär regression, logistisk regression, beslutsträd, slumpmässig skog och Naive Bayes-klassificering. Vi diskuterar vidare ett användningsfall av övervakad inlärning där vi tränar maskinen med hjälp av logistisk tillbakagång .
    
  • Oövervakat lärande : Detta är en process där en modell tränas med hjälp av information som inte är märkt. Denna process kan användas för att gruppera ingångsdata i klasser på grundval av deras statistiska egenskaper. Ej övervakat lärande kallas också cglansanalys som betyder gruppering av objekt baserat på informationen som finns i data som beskriver objekten eller deras relation. Målet är att objekt i en grupp ska likna varandra men skilja sig från objekt i en annan grupp. Några av algoritmerna inkluderar K-betyder kluster, Hierarkiskt kluster etc.
  • Förstärkning lärande: Förstärkning lärande är lärande genom att interagera med ett utrymme eller en miljö.En RL-agent lär sig av konsekvenserna av sina handlingar snarare än från att undervisas uttryckligen. Den väljer sina handlingar utifrån sina tidigare erfarenheter (exploatering) och även genom nya val (utforskning).

Översikt av Scikit Learn

Scikit lär är ett bibliotek som används för att utföra maskininlärning i Python. Scikit lär är ett bibliotek med öppen källkod som är licensierat enligt BSD och kan återanvändas i olika sammanhang, vilket uppmuntrar till akademisk och kommersiell användning. Det ger en rad övervakade och övervakade inlärningsalgoritmer i Python.Scikit lär består av populära algoritmer och bibliotek. Bortsett från det innehåller den också följande paket:

• NumPy
• Matplotlib
• SciPy (vetenskaplig python)

För att implementera Scikit Learn måste vi först importera ovanstående paket. Om du inte känner till dessa bibliotek kan du titta på mina tidigare bloggar på och . Du kan ladda ner dessa två paket med kommandoraden eller om du använder PYCharm, du kan installera den direkt genom att gå till din inställning på samma sätt som du gör för andra paket.

Därefter på ett liknande sättmåste du importera Sklearn.Scikit learning bygger på SciPy (Scientific Python) som måste installeras innan du kan använda Scikit-learning. Du kan hänvisa till detta hemsida för att ladda ner detsamma. Installera också Scipy och hjulpaket om det inte finns, du kan skriva in kommandot nedan:

pip install scipy

Jag har redan laddat ner och installerat den, du kan hänvisa till nedanstående skärmdump för eventuell förvirring.

Efter att ha importerat ovanstående bibliotek, låt oss gräva djupare och förstå hur exakt Scikit lär används.

Scikit lär levereras med exempeluppsättningar, till exempel iris och siffror . Du kan importera datauppsättningarna och spela med dem. Därefter måste du importera SVM som står för Support Vector Machine. SVM är en form av maskininlärning som används för att analysera data.

sqoop-import från oracle till hdfs

Låt oss ta ett exempel där vi tar siffror dataset och det kommer att kategorisera siffrorna för oss, till exempel- 0 1 2 3 4 5 6 7 8 9. Se koden nedan:

importera matplotlib.pyplot som plt från sklearn importera datamängder från sklearn importera svm-siffror = datasets.load_digits () skriv ut (digits.data)

Utgång -

[[0. 0. 5. ..., 0. 0. 0.] [0. 0. 0. ..., 10. 0. 0.] [0. 0. 0. ..., 16. 9. 0.] ..., [0. 0. 1. ..., 6. 0. 0.] [0. 0. 2. ..., 12. 0. 0.] [0. 0. 10. ..., 12. 1. 0.]]

Här har vi just importerat biblioteken, SVM, datamängder och skrivit ut data. Det är ett långt antal siffror där data lagras. Det ger åtkomst till de funktioner som kan användas för att klassificera siffror prover. Därefter kan du också prova några andra åtgärder som mål, bilder etc. Tänk på exemplet nedan:

importera matplotlib.pyplot som plt från sklearn importera datamängder från sklearn importera svm-siffror = datasets.load_digits () skriv ut (digits.target) skriv ut (digits.images [0])

Produktion -

[0 1 2 ..., 8 9 8] // data för data [[0. 0. 5. 13. 9. 1. 0. 0.] // bild av data [0. 0. 13. 15. 10. 15. 5. 0.] [0. 3. 15. 2. 0. 11. 8. 0.] [0. 4. 12. 0. 0. 8. 8. 0.] [0. 5. 8. 0. 0. 9. 8. 0.] [0. 4. 11. 0. 1. 12. 7. 0.] [0. 2. 14. 5. 10. 12. 0. 0. ] [0. 0. 6. 13. 10. 0. 0. 0.]]

Som du kan se ovan trycks målsiffrorna och siffrans bild. siffror. mål ger marken sanningen för siffra dataset, det är numret som motsvarar varje siffrabild. Därefter är data alltid en 2D-array som har en form (n_samples, n_features), även om originaldata kan ha haft en annan form. Men när det gäller siffrorna är varje originalprov en bild med formen (8,8) och kan nås med siffror . bild.

Lärande och förutsägelse

hur man kastar dubbelt till int i Java

Därefter har vi i Scikit learning använt en dataset (exempel på 10 möjliga klasser, siffror från noll till nio) och vi måste förutsäga siffrorna när en bild ges. För att förutsäga klassen behöver vi en uppskattare vilket hjälper till att förutsäga de klasser som osedda prover tillhör. I Scikit Learn har vi en estimator för klassificering som är ett pythonobjekt som implementerar metoderna passform (x, y) och förutsäga (T). Låt oss överväga exemplet nedan:

importera matplotlib.pyplot som plt från sklearn importera datamängder från sklearn importera svm siffror = dataset.load_digits () // dataset clf = svm.SVC (gamma = 0,001, C = 100) skriv ut (len (siffror data)) x, y = siffror.data [: - 1], siffror. mål [: - 1] // träna data clf.fit (x, y) print ('Prediction:', clf.predict (digits.data [-1]) ) // förutsäga data plt.imshow (digits.images [-1], cmap = plt.cm.gray_r, interpolation = 'närmaste') plt.show ()

Utgång -

1796
Förutsägelse: [8]

I exemplet ovan hade vi först hittat längden och laddat 1796 exempel. Därefter har vi använt dessa data som inlärningsdata, där vi måste testa det sista elementet och det första negativa elementet. Vi måste också kontrollera om maskinen har förutsagt rätt data eller inte. För det hade vi använt Matplotlib där vi hade visat bilden av siffror.Så för att avsluta, du har siffradata, du har målet, du passar och förutsäger det och därmed är du bra att gå! Det är verkligen snabbt och enkelt, eller hur?

Du kan också visualisera måletiketterna med en bild, se bara koden nedan:

importera matplotlib.pyplot som plt från sklearn importera datamängder från sklearn importera svm siffror = datasets.load_digits () # Gå med i bilderna och måletiketterna i en lista images_and_labels = list (zip (digits.images, digits.target)) # för varje element i listan för index, (bild, etikett) i enumerate (images_and_labels [: 8]): # initialisera en delplot på 2X4 i i + 1: e position plt. subplot (2, 4, index + 1) # Visa bilder i alla delplottar plt.imshow (bild, cmap = plt.cm.gray_r, interpolation = 'närmast') # Lägg till en titel till varje delplott plt.title ('Träning:' + str (etikett)) # Visa plot plt. show()

Produktion-

Som du kan se i koden ovan har vi använt ”zip” -funktionen för att sammanfoga bilderna och måletiketterna i en lista och sedan spara den i en variabel, säg images_and_labels. Därefter har vi indexerat de första åtta elementen i ett rutnät av 2 med 4 vid varje position. Efter det har vi just visat bilderna med hjälp av Matplotlib och lagt till titeln som ”träning”.

Användningsfall - Förutsägelse med logistisk regression

Problemförklaring - Ett bilföretag har släppt en ny SUV på marknaden. Med hjälp av tidigare data om försäljningen av sina stadsjeepar vill de förutse vilken kategori människor som kan vara intresserade av att köpa denna.

För detta, låt oss se en dataset där jag har Användar-ID, kön, ålder, beräknad lön och inköpt som kolumner. Detta är bara ett exempel på dataset, du kan ladda ner hela dataset från här . När vi väl importerat data i pyCharm ser det lite ut så här.

Låt oss nu förstå dessa data. Som du kan se i ovanstående dataset har vi kategorier som id, kön, ålder etc. Nu baserat på dessa kategorier kommer vi att träna vår maskin och förutsäga nej. av inköp. Så här har vi det oberoende variabler som 'ålder', 'förväntad lön' och beroende variabel som ”köpt”. Nu kommer vi att tillämpa övervakat lärande, dvs. logistisk regressionsalgoritm för att ta reda på antalet inköp med befintlig data.

Låt oss först få en översikt över logistisk regression.

Logistisk tillbakagång - Logistisk regression ger resultat i ett binärt format som används för att förutsäga resultatet av en kategorisk beroende variabel. Det används mest när den beroende variabeln är binär, det vill säga antalet tillgängliga kategorier är två, till exempel är de vanliga resultaten av logistisk regression -

• Ja och nej
• Sant och falskt
• Hög och låg
• Passera och misslyckas

För att börja med koden importerar vi först dessa bibliotek - Numpy, Matplotlib och Pandas. Det är ganska enkelt att importera pandor i Pycharm genom att följa stegen nedan:

Inställningar -> Lägg till paket -> Pandor -> Installera

Efter detta kommer vi att importera datasetet och separata beroende variabel (köpt) och oberoende variabel (ålder, lön) efter:

dataset = pd.read_csv ('Social_Network_Ads.csv') X = dataset.iloc [:, [2, 3]]. värden y = dataset.iloc [:, 4]. värden skriv ut (X) skriv ut (y)

Nästa steg är att träna och testa data. En gemensam strategi är att ta alla märkta data och dela upp i utbildnings- och testundersättningar, vilket vanligtvis tas med ett förhållande på 70-80% för utbildningsundermängd och 20-30% för testundermängd. Därför har vi skapat skapa tränings- och testuppsättningar med kors_validering.

från sklearn.cross_validation importera train_test_split X_train, X_test, y_train, y_test = train_test_split (X, y, test_size = 0.25, random_state = 0)

Vi kan också skala ingångsvärdena för bättre prestanda med StandarScaler enligt nedan:

från sklearn.preprocessing import StandardScaler sc = StandardScaler () X_train = sc.fit_transform (X_train) X_test = sc.transform (X_test)

Nu ska vi skapa vår logistiska regressionsmodell.

matris av objekt i java exempelprogram

från sklearn.linear_model importerar LogisticRegression classifier = LogisticRegression (random_state = 0) classifier.fit (X_train, y_train)

Vi kan använda detta och förutsäga resultaten av vår testuppsättning.

y_pred = classifier.predict (X_test)

Nu kan vi kontrollera hur många förutsägelser som var korrekta och hur många som inte använde förvirringsmatris . Låt oss definiera Y som positiva instanser och N som negativa instanser. De fyra resultaten formuleras i 2 * 2 förvirringsmatris, som visas nedan:

från sklearn.metrics importerar confusion_matrix cm = confusion_matrix (y_test, y_pred) print (cm)

Produktion-

[[65 3] [8 24]]

Därefter, baserat på vår förvirringsmatris, kan vi beräkna noggrannheten. Så i vårt exempel ovan skulle noggrannheten vara:

= TP + TN / FN + FP

= 65 + 24/65 +3+ 8 + 24

= 89%

Vi har gjort detta manuellt! Låt oss nu se hur maskinen beräknar samma för oss, för det har vi en inbyggd funktion 'precision_score' som beräknar noggrannheten och skriver ut den, som visas nedan:

från sklearn.metrics importera precision_score // importera funktionen precision_score-utskrift (precision_score (y_test, y_pred) * 100) // skriver ut noggrannheten

Utgång -

89,0

hurra! Vi har alltså framgångsrikt implementerat logistisk regression med Scikit Learn med en noggrannhet på 89%.

Klicka här för att få den fullständiga källan till ovanstående förutsägelse använder Python Scikit lär biblioteket.

Med detta har vi täckt bara en av de många populära algoritmer som python har att erbjuda.Vi har täckt alla grunderna i Scikit lära sig biblioteket,så att du kan börja träna nu. Ju mer du tränar desto mer lär du dig. Håll dig uppdaterad för ytterligare python-självbloggar!

Har du en fråga till oss? Vänligen nämna det i kommentarsektionen på denna 'Scikit Learn' -blogg så återkommer vi till dig så snart som möjligt. För att få fördjupad kunskap om Python tillsammans med dess olika applikationer kan du för live onlineträning med support dygnet runt och livstidsåtkomst.