Articles

Gebruikte Machine Learning Algoritmes (met Python en R Codes)

Posted on

Note: Dit artikel is oorspronkelijk gepubliceerd op 10 augustus 2015 en bijgewerkt op 9 sept 2017

Overzicht

  • Grote focus op veelgebruikte machine learning algoritmen
  • Algoritmen die worden behandeld- Lineaire regressie, logistische regressie, Naive Bayes, kNN, Random forest, enz.
  • Leer zowel theorie als implementatie van deze algoritmes in R en python

Inleiding

Google’s zelfrijdende auto’s en robots krijgen veel aandacht in de pers, maar de echte toekomst van het bedrijf ligt in machine learning, de technologie waarmee computers slimmer en persoonlijker kunnen worden.

– Eric Schmidt (Google-voorzitter)

We leven waarschijnlijk in de meest bepalende periode van de menselijke geschiedenis. De periode waarin computing verschoof van grote mainframes naar pc’s naar de cloud. Maar wat het bepalend maakt is niet wat er is gebeurd, maar wat er de komende jaren op ons afkomt.

Wat deze periode spannend en boeiend maakt voor iemand als ik is de democratisering van de verschillende tools en technieken, die volgde op de boost in computing. Welkom in de wereld van de data science!

Heden ten dage kan ik als data scientist data-crunching machines bouwen met complexe algoritmen voor een paar dollar per uur. Maar hier komen was niet makkelijk! Ik had mijn donkere dagen en nachten.

Ben jij een beginner op zoek naar een plek om je data science reis te beginnen? We presenteren twee uitgebreide cursussen, vol kennis en data science learning, speciaal voor jou samengesteld om data science (met Python) vanaf nul te leren:

  • Introductie tot Data Science
  • Certified AI & ML Blackbelt+ Program

Wie kan het meest profiteren van deze gids?

Wat ik vandaag geef is waarschijnlijk de meest waardevolle gids, die ik ooit heb gemaakt.

Het idee achter het maken van deze gids is om de reis van aspirant-datawetenschappers en machine learning enthousiastelingen over de hele wereld te vereenvoudigen. Door middel van deze gids, zal ik u in staat stellen om te werken aan machine learning problemen en uit ervaring op te doen. Ik geef een high-level begrip van verschillende machine learning algoritmen samen met R & Python codes om ze uit te voeren. Deze zouden voldoende moeten zijn om je handen vuil te maken.

Essentials of machine learning algorithms with implementation in R and Python

Ik heb met opzet de statistiek achter deze technieken overgeslagen, omdat je die in het begin niet hoeft te begrijpen. Dus, als u op zoek bent naar statistisch begrip van deze algoritmen, moet u elders zoeken.

In het algemeen zijn er 3 soorten algoritmen voor machinaal leren

Supervised Learning

Hoe het werkt: Dit algoritme bestaat uit een doel / uitkomst variabele (of afhankelijke variabele) die moet worden voorspeld uit een gegeven set van voorspellers (onafhankelijke variabelen). Met behulp van deze reeks variabelen genereren we een functie die de inputs in de gewenste outputs omzet. Het opleidingsproces gaat door totdat het model een gewenste nauwkeurigheid heeft bereikt op de opleidingsgegevens. Voorbeelden van Begeleid Leren: Regressie, Beslisboom, Random Forest, KNN, Logistische Regressie enz.

Unsupervised Learning

Hoe het werkt: In dit algoritme hebben we geen doel- of uitkomstvariabele om te voorspellen/schatten. Het wordt gebruikt voor het clusteren van de bevolking in verschillende groepen, die op grote schaal wordt gebruikt voor het segmenteren van klanten in verschillende groepen voor specifieke interventie. Voorbeelden van leren zonder toezicht: Apriori algoritme, K-means.

Reinforcement Learning:

Hoe het werkt: Met dit algoritme wordt de machine getraind om specifieke beslissingen te nemen. Het werkt als volgt: de machine wordt blootgesteld aan een omgeving waarin hij zichzelf voortdurend traint met vallen en opstaan. De machine leert van ervaringen uit het verleden en probeert de best mogelijke kennis te vergaren om nauwkeurige zakelijke beslissingen te nemen. Voorbeeld van Reinforcement Learning: Markov Decision Process

Lijst van veelgebruikte Machine Learning Algoritmes

Hier volgt de lijst van veelgebruikte machine learning algoritmes. Deze algoritmen kunnen op bijna elk gegevensprobleem worden toegepast:

  1. Lineaire regressie
  2. Logistische regressie
  3. Decision Tree
  4. SVM
  5. Naive Bayes
  6. kNN
  7. K-Means
  8. Random Forest
  9. Dimensionality Reduction Algorithms
  10. Gradient Boosting algorithms
    1. GBM
    2. XGBoost
    3. LightGBM
    4. CatBoost

Lineaire Regressie

Het wordt gebruikt om reële waarden te schatten (kosten van huizen, aantal gesprekken, totale verkoop, enz.) op basis van continue variabele(n). Hier wordt een verband gelegd tussen onafhankelijke en afhankelijke variabelen door een best passende lijn te passen. Deze best passende lijn staat bekend als regressielijn en wordt voorgesteld door een lineaire vergelijking Y= a *X + b.

De beste manier om lineaire regressie te begrijpen is door deze ervaring uit de kindertijd opnieuw te beleven. Stel, je vraagt een kind in de vijfde klas om de mensen in zijn klas te rangschikken in oplopende volgorde van gewicht, zonder hen naar hun gewicht te vragen! Wat denk je dat het kind zal doen? Hij/zij zou waarschijnlijk kijken (visueel analyseren) naar de lengte en lichaamsbouw van mensen en ze rangschikken aan de hand van een combinatie van deze zichtbare parameters. Dit is lineaire regressie in het echte leven! Het kind heeft feitelijk bedacht dat lengte en lichaamsbouw gecorreleerd zijn aan het gewicht door een relatie, die eruit ziet als de vergelijking hierboven.

In deze vergelijking:

  • Y – Afhankelijke variabele
  • a – Helling
  • X – Onafhankelijke variabele
  • b – Intercept

Deze coëfficiënten a en b zijn afgeleid op basis van het minimaliseren van de som van het kwadraatverschil van de afstand tussen de datapunten en de regressielijn.

Kijk eens naar het onderstaande voorbeeld. Hier hebben we de best passende lijn gevonden met lineaire vergelijking y=0.2811x+13.9. Met behulp van deze vergelijking kunnen we het gewicht vinden als we de lengte van een persoon kennen.

Lineaire regressie bestaat hoofdzakelijk uit twee typen: Eenvoudige lineaire regressie en meervoudige lineaire regressie. Eenvoudige lineaire regressie wordt gekenmerkt door één onafhankelijke variabele. En meervoudige lineaire regressie (zoals de naam al zegt) wordt gekenmerkt door meerdere (meer dan 1) onafhankelijke variabelen. Bij het vinden van de best passende lijn, kunt u een polynomiale of kromlijnige regressie toepassen. En deze staan bekend als polynomiale of curvilineaire regressie.

Hier is een codeervenster om je hand uit te proberen en je eigen lineaire regressiemodel te bouwen in Python:

R Code

#Load Train and Test datasets#Identify feature and response variable(s) and values must be numeric and numpy arraysx_train <- input_variables_values_training_datasetsy_train <- target_variables_values_training_datasetsx_test <- input_variables_values_test_datasetsx <- cbind(x_train,y_train)# Train the model using the training sets and check scorelinear <- lm(y_train ~ ., data = x)summary(linear)#Predict Outputpredicted= predict(linear,x_test)

Logistische Regressie

Verwarring je niet door de naam! Het is een classificatie algoritme en geen regressie algoritme. Het wordt gebruikt om discrete waarden te schatten (binaire waarden zoals 0/1, ja/nee, waar/waar) gebaseerd op een gegeven set van onafhankelijke variabelen. In eenvoudige woorden: het voorspelt de waarschijnlijkheid van het optreden van een gebeurtenis door gegevens aan te passen aan een logitfunctie. Daarom wordt het ook wel logit regressie genoemd. Aangezien het de waarschijnlijkheid voorspelt, liggen de uitvoerwaarden tussen 0 en 1 (zoals verwacht).

Wederom, laten we dit proberen te begrijpen aan de hand van een eenvoudig voorbeeld.

Let op: je vriend geeft je een puzzel om op te lossen. Er zijn slechts 2 scenario’s – of je lost het op of je doet het niet. Stel je nu eens voor dat je een groot aantal puzzels / quizzen krijgt in een poging om te begrijpen in welke onderwerpen je goed bent. De uitkomst van dit onderzoek zou ongeveer als volgt zijn – als je een op trignometrie gebaseerd probleem uit de tiende klas krijgt, is de kans dat je het oplost 70%. Als het daarentegen een geschiedenisvraag uit de vijfde klas is, is de kans dat je een antwoord krijgt slechts 30%. Dit is wat Logistische Regressie u biedt.

Om tot de wiskunde te komen: de logistische kans op de uitkomst wordt gemodelleerd als een lineaire combinatie van de voorspellende variabelen.

odds= p/ (1-p) = kans dat gebeurtenis zich voordoet / kans dat gebeurtenis zich niet voordoetrenceln(odds) = ln(p/(1-p))logit(p) = ln(p/(1-p)) = b0+b1X1+b2X2+b3X3....+bkXk

Hierboven is p de waarschijnlijkheid van aanwezigheid van het kenmerk van belang. Het kiest parameters die de waarschijnlijkheid van het waarnemen van de steekproefwaarden maximaliseren in plaats van die de som van gekwadrateerde fouten minimaliseren (zoals in gewone regressie).

Nu, vraag je je misschien af, waarom een log nemen? Laten we voor de eenvoud maar zeggen dat dit een van de beste wiskundige manieren is om een stapfunctie te repliceren. Ik kan in meer details treden, maar dat zal het doel van dit artikel voorbijschieten.

Bouw hier je eigen logistische regressiemodel in Python en controleer de nauwkeurigheid:

R Code

x <- cbind(x_train,y_train)# Train the model using the training sets and check scorelogistic <- glm(y_train ~ ., data = x,family='binomial')summary(logistic)#Predict Outputpredicted= predict(logistic,x_test)

Verder…

Er zijn veel verschillende stappen die kunnen worden geprobeerd om het model te verbeteren:

  • interactietermen opnemen
  • kenmerken verwijderen
  • regularisatietechnieken
  • een niet-lineair model gebruiken

Decision Tree

Dit is een van mijn favoriete algoritme en ik gebruik het vrij vaak. Het is een type supervised learning algoritme dat meestal wordt gebruikt voor classificatie problemen. Verrassend genoeg werkt het voor zowel categorische als continue afhankelijke variabelen. In dit algoritme splitsen we de populatie in twee of meer homogene sets. Dit wordt gedaan op basis van de meest significante attributen/onafhankelijke variabelen om zo verschillende groepen te maken als mogelijk. Voor meer details, kunt u lezen: Decision Tree Simplified.

bron: statsexchange

In de bovenstaande afbeelding kunt u zien dat de bevolking wordt ingedeeld in vier verschillende groepen op basis van meerdere attributen om te identificeren ‘of ze zullen spelen of niet’. Om de bevolking in verschillende heterogene groepen te verdelen, worden verschillende technieken gebruikt, zoals Gini, Information Gain, Chi-kwadraat, entropie.

De beste manier om te begrijpen hoe een beslisboom werkt, is door Jezzball te spelen – een klassiek spel van Microsoft (afbeelding hieronder). In essentie heb je een kamer met bewegende muren en moet je muren zo maken dat het maximale gebied wordt vrijgemaakt zonder ballen.

Dus, elke keer dat je de kamer splitst met een muur, probeer je 2 verschillende populaties te creëren in dezelfde kamer. Beslissingsbomen werken op een vergelijkbare manier door een populatie in zo verschillend mogelijke groepen te verdelen.

Meer: Simplified Version of Decision Tree Algorithms

Laten we onze handen vuil maken en onze eigen beslisboom coderen in Python!

R Code

library(rpart)x <- cbind(x_train,y_train)# grow tree fit <- rpart(y_train ~ ., data = x,method="class")summary(fit)#Predict Output predicted= predict(fit,x_test)

SVM (Support Vector Machine)

Het is een classificatiemethode. In dit algoritme plotten we elk gegevensitem als een punt in een n-dimensionale ruimte (waarbij n het aantal kenmerken is dat je hebt), waarbij de waarde van elk kenmerk de waarde van een bepaalde coördinaat is.

Bijvoorbeeld, als we slechts twee kenmerken hadden zoals Lengte en Haarlengte van een individu, zouden we deze twee variabelen eerst plotten in een tweedimensionale ruimte waar elk punt twee coördinaten heeft (deze coördinaten staan bekend als Support Vectors)

Nu zullen we een lijn vinden die de gegevens verdeelt tussen de twee verschillend geclassificeerde groepen van gegevens. Dit is de lijn waarbij de afstanden tot het dichtstbijzijnde punt in elk van de twee groepen het grootst zijn.

In het hierboven getoonde voorbeeld is de lijn die de gegevens in twee verschillend ingedeelde groepen verdeelt de zwarte lijn, omdat de twee dichtstbijzijnde punten het verst van de lijn af liggen. Deze lijn is onze classificator. Afhankelijk van waar de testgegevens aan weerszijden van de lijn terechtkomen, kunnen we de nieuwe gegevens in die klasse indelen.

Meer: Vereenvoudigde versie van Support Vector Machine

Denk aan dit algoritme als het spelen van JezzBall in n-dimensionale ruimte. De aanpassingen in het spel zijn:

  • Je kunt lijnen/vlakken tekenen onder elke hoek (in plaats van alleen horizontaal of verticaal zoals in het klassieke spel)
  • Het doel van het spel is om ballen van verschillende kleuren in verschillende kamers te scheiden.
  • En de ballen bewegen niet.

Probeer je hand en ontwerp een SVM model in Python via dit codeervenster:

R Code

library(e1071)x <- cbind(x_train,y_train)# Fitting modelfit <-svm(y_train ~ ., data = x)summary(fit)#Predict Output predicted= predict(fit,x_test)

Naive Bayes

Het is een classificatie techniek gebaseerd op Bayes’ theorema met een aanname van onafhankelijkheid tussen voorspellers. Eenvoudig gezegd gaat een Naive Bayes classificator ervan uit dat de aanwezigheid van een bepaald kenmerk in een klasse niet gerelateerd is aan de aanwezigheid van een ander kenmerk. Bijvoorbeeld, een vrucht kan als appel worden beschouwd als hij rood, rond en ongeveer 15 cm in diameter is. Zelfs als deze kenmerken van elkaar afhangen of van het bestaan van de andere kenmerken, zou een naïeve Bayes classificator al deze eigenschappen beschouwen als onafhankelijk bijdragend aan de waarschijnlijkheid dat deze vrucht een appel is.

Naïeve Bayesiaanse modellen zijn eenvoudig te bouwen en bijzonder nuttig voor zeer grote datasets. Naast de eenvoud staat Naive Bayes erom bekend zelfs zeer geavanceerde classificatiemethoden te overtreffen.

Bayes theorema biedt een manier om de posterior waarschijnlijkheid P(c|x) te berekenen uit P(c), P(x) en P(x|c). Bekijk de vergelijking hieronder:

Hier,

  • P(c|x) is de posterior waarschijnlijkheid van klasse (doel) gegeven voorspeller (attribuut).
  • P(c) is de voorafgaande waarschijnlijkheid van de klasse.
  • P(x|c) is de waarschijnlijkheid die de waarschijnlijkheid is van de voorspeller gegeven de klasse.
  • P(x) is de voorafgaande waarschijnlijkheid van de voorspeller.

Voorbeeld: Laten we het begrijpen aan de hand van een voorbeeld. Hieronder heb ik een training dataset van het weer en bijbehorende doelvariabele ‘Play’. Nu moeten we classificeren of spelers zullen spelen of niet, gebaseerd op de weersomstandigheden.

Stap 1: Converteer de dataset naar een frequentietabel

Stap 2: Maak een waarschijnlijkheidstabel door de waarschijnlijkheden te bepalen, zoals kans op bewolking = 0,29 en kans op spelen is 0,64.

Stap 3: Gebruik nu de Naive Bayesiaanse vergelijking om de posterior waarschijnlijkheid voor elke klasse te berekenen. De klasse met de hoogste posterior waarschijnlijkheid is de uitkomst van de voorspelling.

Probleem: Spelers zullen betalen als het zonnig weer is, is deze bewering juist?

We kunnen het oplossen met de hierboven besproken methode, dus P(Ja | Zonnig) = P( Zonnig | Ja) * P(Ja) / P (Zonnig)

Hier hebben we P (Zonnig | Ja) = 3/9 = 0.33, P(Sunny) = 5/14 = 0.36, P( Yes)= 9/14 = 0.64

Nu, P (Yes | Sunny) = 0.33 * 0.64 / 0.36 = 0.60, wat een hogere waarschijnlijkheid heeft.

Naive Bayes gebruikt een vergelijkbare methode om de waarschijnlijkheid van verschillende klassen te voorspellen op basis van verschillende attributen. Dit algoritme wordt meestal gebruikt bij tekstclassificatie en bij problemen met meerdere klassen.

Codeer een Naive Bayes classificatiemodel in Python:

R Code

library(e1071)x <- cbind(x_train,y_train)# Fitting modelfit <-naiveBayes(y_train ~ ., data = x)summary(fit)#Predict Output predicted= predict(fit,x_test)

kNN (k- Nearest Neighbors)

Het kan zowel voor classificatie- als regressieproblemen worden gebruikt. In de industrie wordt het echter meer gebruikt voor classificatieproblemen. K nearest neighbors is een eenvoudig algoritme dat alle beschikbare gevallen opslaat en nieuwe gevallen classificeert door een meerderheidsstemming van zijn k buren. Het geval dat aan de klasse wordt toegewezen, komt het meest voor bij zijn K naaste buren, gemeten door een afstandsfunctie.

Deze afstandsfuncties kunnen Euclidische, Manhattan, Minkowski- en Hamming-afstand zijn. De eerste drie functies worden gebruikt voor continue functies en de vierde (Hamming) voor categorische variabelen. Als K = 1, dan wordt het geval eenvoudigweg toegewezen aan de klasse van zijn naaste buur. Soms blijkt het kiezen van K een uitdaging te zijn bij het uitvoeren van kNN modellering.

Meer: Inleiding tot k-nearest neighbors : Vereenvoudigd.

KNN kan gemakkelijk in kaart worden gebracht in ons echte leven. Als je iets te weten wilt komen over een persoon van wie je geen informatie hebt, kun je misschien zijn goede vrienden en de kringen waarin hij zich beweegt te weten komen en toegang krijgen tot zijn informatie!

Dingen om te overwegen voordat u kNN kiest:

  • KNN is computationeel duur
  • Variabelen moeten worden genormaliseerd anders hoger bereik variabelen kan bias het
  • Werkt aan pre-processing fase meer voordat je gaat voor kNN als een uitbijter, ruisverwijdering

Python Code

R Code

library(knn)x <- cbind(x_train,y_train)# Fitting modelfit <-knn(y_train ~ ., data = x,k=5)summary(fit)#Predict Output predicted= predict(fit,x_test)

K-Means

Het is een type algoritme zonder toezicht dat het clustering probleem oplost. De procedure volgt een eenvoudige en gemakkelijke manier om een gegevenreeks door een bepaald aantal clusters (veronderstel k clusters) te classificeren. Gegevenspunten binnen een cluster zijn homogeen en heterogeen ten opzichte van soortgenoten.

Herinner je je het uitzoeken van vormen uit inktvlekken? k middelen is enigszins vergelijkbaar deze activiteit. Je kijkt naar de vorm en de spreiding om te ontcijferen hoeveel verschillende clusters / populaties er aanwezig zijn!

Hoe K-means clusters vormt:

  1. K-means kiest k aantal punten voor elke cluster, die centroïden worden genoemd.
  2. Elk gegevenspunt vormt een cluster met de dichtstbijzijnde centroïden, d.w.z. k clusters.
  3. Vindt de centroïde van elk cluster op basis van bestaande clusterleden. Hier hebben we nieuwe centroïden.
  4. Omdat we nieuwe centroïden hebben, herhaal stap 2 en 3. Zoek de dichtstbijzijnde afstand voor elk gegevenspunt van nieuwe centroïden en krijg geassocieerd met nieuwe k-clusters. Herhaal dit proces totdat convergentie optreedt, d.w.z. de centroïden veranderen niet.

Hoe de waarde van K te bepalen:

In K-means hebben we clusters en elke cluster heeft zijn eigen centroïde. De som van het kwadraat van het verschil tussen het zwaartepunt en de gegevenspunten binnen een cluster vormt de som van de kwadratische waarde voor die cluster. Ook wanneer de som van de kwadratische waarden voor alle clusters worden opgeteld, wordt het de totale interne kwadratische waarde voor de clusteroplossing.

We weten dat als het aantal clusters toeneemt, deze waarde blijft dalen, maar als je het resultaat uitzet, zie je dat de som van de kwadratische afstand sterk afneemt tot een bepaalde waarde van k, en daarna veel langzamer. Hier kunnen we het optimale aantal clusters vinden.

Python Code

R Code

library(cluster)fit <- kmeans(X, 3) # 5 cluster solution

Random Forest

Random Forest is een handelsmerkterm voor een ensemble van beslisbomen. In Random Forest, hebben we verzameling van beslissingsbomen (zo bekend als “Forest”). Om een nieuw object te classificeren op basis van attributen, geeft elke boom een classificatie en zeggen we dat de boom “stemt” voor die klasse. Het bos kiest de classificatie met de meeste stemmen (over alle bomen in het bos).

Elke boom wordt & als volgt gegroeid:

  1. Als het aantal gevallen in de trainingsset N is, dan wordt willekeurig maar met vervanging een steekproef van N gevallen genomen. Deze steekproef wordt de trainingsset voor het groeien van de boom.
  2. Als er M invoervariabelen zijn, wordt een getal m<<M gespecificeerd zodat bij elk knooppunt m variabelen willekeurig uit de M worden gekozen en de beste splitsing op deze m wordt gebruikt om het knooppunt te splitsen. De waarde van m wordt constant gehouden tijdens het groeien van het bos.
  3. Elke boom wordt zo groot mogelijk gekweekt. Er wordt niet gesnoeid.

Voor meer details over dit algoritme, de vergelijking met beslissingsbomen en de afstemming van modelparameters, raad ik u aan deze artikelen te lezen:

  1. Inleiding tot Random forest – Vereenvoudigd

  2. Vergelijking van een CART-model met Random Forest (deel 1)

  3. Vergelijking van een Random Forest met een CART-model (deel 2)

  4. De parameters van uw Random Forest-model afstemmen

Python-code:

R-code

library(randomForest)x <- cbind(x_train,y_train)# Fitting modelfit <- randomForest(Species ~ ., x,ntree=500)summary(fit)#Predict Output predicted= predict(fit,x_test)

Dimensionaliteitsreductie-algoritmen

In de afgelopen 4-5 jaar is er een exponentiële toename geweest van het vastleggen van gegevens in alle mogelijke stadia. Bedrijven/overheidsinstellingen/onderzoeksorganisaties komen niet alleen met nieuwe bronnen, maar leggen ook zeer gedetailleerd gegevens vast.

Bijv: E-commerce bedrijven zijn het vastleggen van meer details over de klant, zoals hun demografische gegevens, web crawling geschiedenis, wat ze leuk of niet leuk vinden, aankoop geschiedenis, feedback en vele anderen om hen persoonlijke aandacht meer dan uw dichtstbijzijnde kruidenier.

Als een data scientist, de gegevens die we aangeboden krijgen ook bestaan uit vele functies, dit klinkt goed voor het bouwen van een goede robuuste model, maar er is een uitdaging. Hoe identificeer je zeer significante variabele(n) uit 1000 of 2000? In dergelijke gevallen helpt het algoritme voor dimensionaliteitsreductie ons, samen met diverse andere algoritmen zoals Decision Tree, Random Forest, PCA, Factoranalyse, Identificeren op basis van correlatiematrix, missing value ratio en andere.

Om meer over deze algoritmen te weten te komen, kunt u de “Beginnersgids voor dimensiereductie-technieken” lezen.

Python Code

R Code

library(stats)pca <- princomp(train, cor = TRUE)train_reduced <- predict(pca,train)test_reduced <- predict(pca,test)

Gradient Boosting Algorithms

10.1. GBM

GBM is een boosting algoritme dat wordt gebruikt wanneer we te maken hebben met veel data om een voorspelling te doen met hoge voorspellingskracht. Boosting is eigenlijk een ensemble van leeralgoritmen die de voorspelling van verschillende basisschatters combineert om de robuustheid te verbeteren ten opzichte van een enkele schatter. Het combineert meerdere zwakke of gemiddelde voorspellers tot een sterke voorspeller. Deze boosting-algoritmen doen het altijd goed in data science-wedstrijden zoals Kaggle, AV Hackathon, CrowdAnalytix.

Meer: Meer weten over Boosting algoritmes in detail

Python Code

R Code

library(caret)x <- cbind(x_train,y_train)# Fitting modelfitControl <- trainControl( method = "repeatedcv", number = 4, repeats = 4)fit <- train(y ~ ., data = x, method = "gbm", trControl = fitControl,verbose = FALSE)predicted= predict(fit,x_test,type= "prob")

GradientBoostingClassifier en Random Forest zijn twee verschillende boosting tree classifier en vaak vragen mensen naar het verschil tussen deze twee algoritmes.

10.2. XGBoost

Een ander klassiek gradient boosting algoritme dat bekend staat als de beslissende keuze tussen winnen en verliezen in sommige Kaggle competities.

De XGBoost heeft een immens hoog voorspellend vermogen waardoor het de beste keuze is voor nauwkeurigheid in evenementen omdat het zowel een lineair model als het tree learning algoritme bezit, waardoor het algoritme bijna 10x sneller is dan bestaande gradient booster technieken.

De ondersteuning omvat verschillende doelfuncties, waaronder regressie, classificatie en rangschikking.

Eén van de interessantste dingen aan XGBoost is dat het ook wel een geregulariseerde boostingtechniek wordt genoemd. Dit helpt om overfit-modellering te verminderen en heeft een enorme ondersteuning voor een reeks talen, zoals Scala, Java, R, Python, Julia en C++.

Ondersteunt gedistribueerde en wijdverspreide training op vele machines die GCE, AWS, Azure en Yarn clusters omvatten. XGBoost kan ook worden geïntegreerd met Spark, Flink en andere cloud dataflow systemen met een ingebouwde cross validatie bij elke iteratie van het boosting proces.

Om meer te leren over XGBoost en parameter tuning, bezoek https://www.analyticsvidhya.com/blog/2016/03/complete-guide-parameter-tuning-xgboost-with-codes-python/.

Python Code:



R Code:


require(caret)x <- cbind(x_train,y_train)# Fitting modelTrainControl <- trainControl( method = "repeatedcv", number = 10, repeats = 4)model<- train(y ~ ., data = x, method = "xgbLinear", trControl = TrainControl,verbose = FALSE)OR model<- train(y ~ ., data = x, method = "xgbTree", trControl = TrainControl,verbose = FALSE)predicted <- predict(model, x_test)


10.3. LightGBM


LightGBM is een gradient boosting raamwerk dat gebruik maakt van boomgebaseerde leeralgoritmen. Het is ontworpen om gedistribueerd en efficiënt te zijn met de volgende voordelen:


    

  • Snellere trainingssnelheid en hogere efficiëntie
    • 

  • Lager geheugengebruik
    • 

  • Betere nauwkeurigheid
    • 

  • Parallel en GPU leren ondersteund
    • 

  • In staat om met grootschalige data om te gaan
    • 



Het framework is een snelle en high-performance gradient boosting die gebaseerd is op beslisboom algoritmen, gebruikt voor ranking, classificatie en vele andere machine learning taken. Het is ontwikkeld onder het Distributed Machine Learning Toolkit Project van Microsoft.


Omdat LightGBM is gebaseerd op beslisboomalgoritmen, splitst het de boom bladwijs met de beste fit, terwijl andere boosting-algoritmen de boom diepte- of niveau-wijs splitsen in plaats van blad-wijs. Dus bij het groeien op hetzelfde blad in Light GBM, kan het blad-wijs algoritme meer verlies beperken dan het niveau-wijs algoritme en resulteert dus in veel betere nauwkeurigheid die zelden kan worden bereikt door een van de bestaande boosting algoritmen.


Ook is het verrassend zeer snel, vandaar het woord ‘Light’.


Raadpleeg het artikel om meer te weten te komen over LightGBM: https://www.analyticsvidhya.com/blog/2017/06/which-algorithm-takes-the-crown-light-gbm-vs-xgboost/


Python-code:


data = np.random.rand(500, 10) # 500 entities, each contains 10 featureslabel = np.random.randint(2, size=500) # binary targettrain_data = lgb.Dataset(data, label=label)test_data = train_data.create_valid('test.svm')param = {'num_leaves':31, 'num_trees':100, 'objective':'binary'}param = 'auc'num_round = 10bst = lgb.train(param, train_data, num_round, valid_sets=)bst.save_model('model.txt')# 7 entities, each contains 10 featuresdata = np.random.rand(7, 10)ypred = bst.predict(data)




R-code:


library(RLightGBM)data(example.binary)#Parametersnum_iterations <- 100config <- list(objective = "binary", metric="binary_logloss,auc", learning_rate = 0.1, num_leaves = 63, tree_learner = "serial", feature_fraction = 0.8, bagging_freq = 5, bagging_fraction = 0.8, min_data_in_leaf = 50, min_sum_hessian_in_leaf = 5.0)#Create data handle and boosterhandle.data <- lgbm.data.create(x)lgbm.data.setField(handle.data, "label", y)handle.booster <- lgbm.booster.create(handle.data, lapply(config, as.character))#Train for num_iterations iterations and eval every 5 stepslgbm.booster.train(handle.booster, num_iterations, 5)#Predictpred <- lgbm.booster.predict(handle.booster, x.test)#Test accuracysum(y.test == (y.pred > 0.5)) / length(y.test)#Save model (can be loaded again via lgbm.booster.load(filename))lgbm.booster.save(handle.booster, filename = "/tmp/model.txt")


Als u bekend bent met het Caret-pakket in R, is dit een andere manier om het LightGBM te implementeren.


require(caret)require(RLightGBM)data(iris)model <-caretModel.LGBM()fit <- train(Species ~ ., data = iris, method=model, verbosity = 0)print(fit)y.pred <- predict(fit, iris)library(Matrix)model.sparse <- caretModel.LGBM.sparse()#Generate a sparse matrixmat <- Matrix(as.matrix(iris), sparse = T)fit <- train(data.frame(idx = 1:nrow(iris)), iris$Species, method = model.sparse, matrix = mat, verbosity = 0)print(fit)


10.4. Catboost


CatBoost is een recent open-sourced machine learning algoritme van Yandex. Het kan gemakkelijk integreren met deep learning frameworks zoals Google’s TensorFlow en Apple’s Core ML.


Het beste deel over CatBoost is dat het geen uitgebreide datatraining vereist zoals andere ML-modellen, en kan werken op een verscheidenheid aan gegevensformaten; niet ondermijnend hoe robuust het kan zijn.


Zorg ervoor dat je goed omgaat met ontbrekende gegevens voordat je verder gaat met de implementatie.


Catboost kan automatisch omgaan met categorische variabelen zonder de typeconversiefout te tonen, waardoor je je kunt richten op het beter afstemmen van je model in plaats van het uitzoeken van triviale fouten.


Lees meer over Catboost in dit artikel: https://www.analyticsvidhya.com/blog/2017/08/catboost-automated-categorical-data/


Python-code:


import pandas as pdimport numpy as npfrom catboost import CatBoostRegressor#Read training and testing filestrain = pd.read_csv("train.csv")test = pd.read_csv("test.csv")#Imputing missing values for both train and testtrain.fillna(-999, inplace=True)test.fillna(-999,inplace=True)#Creating a training set for modeling and validation set to check model performanceX = train.drop(, axis=1)y = train.Item_Outlet_Salesfrom sklearn.model_selection import train_test_splitX_train, X_validation, y_train, y_validation = train_test_split(X, y, train_size=0.7, random_state=1234)categorical_features_indices = np.where(X.dtypes != np.float)#importing library and building modelfrom catboost import CatBoostRegressormodel=CatBoostRegressor(iterations=50, depth=3, learning_rate=0.1, loss_function='RMSE')model.fit(X_train, y_train,cat_features=categorical_features_indices,eval_set=(X_validation, y_validation),plot=True)submission = pd.DataFrame()submission = testsubmission = testsubmission = model.predict(test)


R-code:


set.seed(1)require(titanic)require(caret)require(catboost)tt <- titanic::titanic_traindata <- as.data.frame(as.matrix(tt), stringsAsFactors = TRUE)drop_columns = c("PassengerId", "Survived", "Name", "Ticket", "Cabin")x <- datay <- datafit_control <- trainControl(method = "cv", number = 4,classProbs = TRUE)grid <- expand.grid(depth = c(4, 6, 8),learning_rate = 0.1,iterations = 100, l2_leaf_reg = 1e-3, rsm = 0.95, border_count = 64)report <- train(x, as.factor(make.names(y)),method = catboost.caret,verbose = TRUE, preProc = NULL,tuneGrid = grid, trControl = fit_control)print(report)importance <- varImp(report, scale = FALSE)print(importance)


Projecten


Nu is het tijd om de sprong te wagen en daadwerkelijk met andere echte datasets te spelen. Dus ben je klaar om de uitdaging aan te gaan? Versnel je data science-reis met de volgende oefenproblemen:







Practice Problem: Food Demand Forecasting Challenge
Voorspel de vraag naar maaltijden voor een maaltijdbezorger





Practice Problem: HR Analytics Uitdaging
Identificeer de werknemers met de meeste kans op promotie





Praktijkprobleem: Aantal upvotes voorspellen
Voorspel het aantal upvotes op een vraag gesteld bij een online vraag &antwoordplatform






Eindopmerkingen


Nu al, weet ik zeker dat je een idee hebt van veelgebruikte algoritmen voor machinaal leren. Mijn enige bedoeling bij het schrijven van dit artikel en het geven van de codes in R en Python is om je meteen op weg te helpen. Als je machinaal leren onder de knie wilt krijgen, begin dan meteen. Pak problemen op, ontwikkel een fysiek begrip van het proces, pas deze codes toe en zie het plezier! 



	
		
	

            
            

        				
	
	
	
    
        	

            
	



		

		
Geef een reactie 
Het e-mailadres wordt niet gepubliceerd. Vereiste velden zijn gemarkeerd met *