Apprentissage automatique en R pour les débutants avec exemple

Ce blog sur l'apprentissage automatique avec R vous aide à apprendre les concepts de base de l'apprentissage automatique et à implémenter différents algorithmes d'apprentissage automatique avec R.

Apprentissage automatique avec R

L'apprentissage automatique est le présent et l'avenir! Du moteur de recommandation de Netflix à la voiture autonome de Google, tout est en apprentissage automatique. Ce blog sur l'apprentissage automatique avec R vous aide à comprendre les concepts de base de l'apprentissage automatique suivis de différents algorithmes d'apprentissage automatique et à implémenter ces algorithmes d'apprentissage automatique avec R.



Ce blog sur «Machine Learning avec R» comprend les sections suivantes:



convertisseur binaire en décimal java

Apprentissage automatique avec R | Edureka

Comprendre l'apprentissage automatique

Fish1 - Apprentissage automatique avec R - Edureka



Comment savez-vous que tout cela est du poisson?



En tant qu'enfant, vous avez peut-être rencontré une photo d'un poisson et vos enseignants de maternelle ou vos parents vous auraient dit qu'il s'agit d'un poisson et qu'il présente des caractéristiques spécifiques, comme des nageoires, des branchies, une paire de yeux, une queue et ainsi de suite. Désormais, chaque fois que votre cerveau rencontre une image avec ces caractéristiques, il l'enregistre automatiquement en tant que poisson parce que votre cerveau a appris que c'est un poisson.

C’est ainsi que notre cerveau fonctionne, mais qu’en est-il d’une machine? Si la même image est transmise à une machine, comment la machine l'identifiera-t-elle comme étant un poisson?

C'est là que M Apprentissage achine entre. Nous continuerons d'alimenter des images d'un poisson sur un ordinateur avec l'étiquette 'poisson' jusqu'à ce que la machine apprend toutes les fonctionnalités associées avec un poisson.

Une fois que la machine aura appris toutes les fonctionnalités associées à un poisson, nous lui fournirons de nouvelles données pour déterminer ce qu'il a appris.

En d'autres termes, Données brutes / données d'entraînement est donnée à la machine, de sorte qu'elle apprend toutes les fonctionnalités associées au Données d'entraînement. Une fois, l'apprentissage est fait, il est donné Nouvelles données / données de test pour déterminer dans quelle mesure la machine a appris.

Avançons dans ce blog Machine Learning avec R et comprenons les types de Machine Learning.

Types d'apprentissage automatique

  • Enseignement supervisé:

L'algorithme d'apprentissage supervisé apprend à partir d'un ensemble de données connu (données d'entraînement) qui a des étiquettes pour faire des prédictions.

La régression et la classification sont quelques exemples d'apprentissage supervisé.

#Classification:

La classification détermine à quel ensemble de catégories appartient une nouvelle observation, c'est-à-dire qu'un algorithme de classification apprend toutes les caractéristiques et étiquettes des données d'apprentissage et lorsque de nouvelles données lui sont données, il doit attribuer des étiquettes aux nouvelles observations en fonction de ce qu'il a appris à partir des données d'entraînement.

Pour cet exemple, si la première observation porte l'étiquette «Homme», alors elle est correctement classée mais si elle reçoit l'étiquette «Femme», la classification est erronée. De même pour la deuxième observation, si l'étiquette donnée est «Femme», elle est correctement classée, sinon la classification est erronée.

#Régression:

La régression est un algorithme d'apprentissage supervisé qui aide à déterminer comment une variable influence une autre variable.

Ici, «living_area» est la variable indépendante et «price» est la variable dépendante, c'est-à-dire que nous déterminons comment le «prix» varie par rapport à «living_area».

  • Apprentissage non supervisé:

L'algorithme d'apprentissage non supervisé tire des inférences à partir de données qui n'ont pas d'étiquettes.

Clustering est un exemple d'apprentissage non supervisé. «K-means», «Hierarchical», «Fuzzy C-Means» sont quelques exemples d'algorithmes de clustering.

Dans cet exemple, l'ensemble des observations est divisé en deux groupes. Le regroupement se fait sur la base de la similitude entre les observations. Il existe une forte similitude intra-cluster et une faible similitude inter-cluster, c'est-à-dire qu'il y a une très forte similitude entre tous les bus mais une faible similitude entre les bus et les voitures.

  • Apprentissage par renforcement:

L'apprentissage par renforcement est un type d'algorithme d'apprentissage automatique dans lequel le machine / agent dans un environnement apprend le comportement idéal afin de maximiser ses performances. Un simple retour d'information sur la récompense est nécessaire pour que l'agent apprenne son comportement, c'est ce que l'on appelle le signal de renforcement .

Prenons Pac-Man par exemple. Tant que pacman continue de manger de la nourriture, il gagne des points, mais quand il s'écrase contre un monstre, il perd la vie. Ainsi, Pacman apprend qu'il doit manger plus de nourriture et éviter les monstres afin d’améliorer ses performances.

Implémentation de l'apprentissage automatique avec R:

Régression linéaire:

Nous allons travailler avec l'ensemble de données des diamants pour mettre en œuvre un algorithme de régression linéaire:

Description de l'ensemble de données:

Avant de construire un modèle sur les données, nous sommes censés diviser les données en ensembles «train» et «test». Le modèle sera construit sur l'ensemble «train» et sa précision sera vérifiée sur l'ensemble «test».

Nous devons charger le package «caTools» pour diviser les données en deux ensembles.

bibliothèque (caTools)

Le package «caTools» fournit une fonction «sample.split ()» qui aide à diviser les données.

sample.split (prix des diamants $, SplitRatio = 0,65) -> split_index

65% des observations de la colonne des prix ont reçu l'étiquette «vrai» et les 35% restants ont reçu l'étiquette «faux».

sous-ensemble (losanges, split_index == T) -> train sous-ensemble (losanges, split_index == F) -> test

Toutes les observations qui ont le libellé 'vrai' ont été stockées dans le ' objet 'train' et les observations portant l'étiquette «faux» ont été attribuées à l'ensemble «test».

Maintenant que le fractionnement est terminé et que nous avons nos ensembles «train» et «test», il est temps de créer le modèle de régression linéaire sur l'ensemble d'apprentissage.

Nous allons utiliser la fonction 'lm ()' pour construire le modèle de régression linéaire sur les données 'train'. Nous déterminons le prix des diamants par rapport à toutes les autres variables de l'ensemble de données. Le modèle construit est stocké dans l'objet «mod_regress».

lm (prix ~., data = train) -> mod_regress

Maintenant que nous avons construit le modèle, nous devons faire des prédictions sur l'ensemble «test». La fonction «prédire ()» est utilisée pour obtenir des prédictions. Il prend deux arguments: le modèle construit et le ensemble d'essai. Les résultats prédits sont stockés dans l'objet «result_regress».

prédire (mod_regress, test) -> result_regress

Lions les valeurs de prix réelles de l'ensemble de données 'test' et les valeurs prédites dans un seul ensemble de données à l'aide de la fonction 'cbind ()'. La nouvelle trame de données est stockée dans 'Final_Data'

cbind (Actual = test $ price, Predicted = result_regress) -> Final_Data 
as.data.frame (Final_Data) -> Final_Data

Un coup d'œil sur les 'Données_finales' qui comprennent les valeurs réelles et les valeurs prévues:

Trouvons l'erreur en soustrayant les valeurs prévues des valeurs réelles et ajoutons cette erreur en tant que nouvelle colonne aux 'Données_finales':

(Final_Data $ Actual- Final_Data $ Predicted) -> erreur
cbind (Final_Data, erreur) -> Final_Data

Un coup d'œil sur les «Données_finales» qui comprennent également l'erreur de prédiction:

Maintenant, nous allons continuer et calculer ' Erreur quadratique moyenne » ce qui donne une erreur globale pour toutes les prédictions

rmse1<-sqrt(mean(Final_Data$error^2)) 
rmse1

À l'avenir, construisons un autre modèle, afin que nous puissions comparer la précision de ces deux modèles et déterminer lequel est le meilleur.

Nous allons construire un nouveau modèle de régression linéaire sur l'ensemble «train», mais cette fois, nous allons supprimer les colonnes «x» et «y» des variables indépendantes, c'est-à-dire que le «prix» des diamants est déterminé par tous les colonnes sauf «x» et «y».

Le modèle construit est stocké dans «mod_regress2»:

lm (prix ~.-y-z, data = train) -> mod_regress2

Les résultats prévus sont stockés dans 'result_regress2'

prédire (mod_regress2, test) -> result_regress2

Les valeurs réelles et prévues sont combinées et stockées dans 'Final_Data2':

cbind (Actual = test $ price, Predicted = result_regress2) -> Final_Data2 
as.data.frame (Final_Data2) -> Final_Data2

Ajoutons également l'erreur de prédiction à 'Final_Data2'

(Final_Data2 $ Actual- Final_Data2 $ Predicted) -> error2
cbind (Final_Data2, erreur2) -> Final_Data2

Un coup d'œil sur 'Final_Data2':

Recherche de l'erreur quadratique moyenne pour obtenir l'erreur globale:

rmse2<-sqrt(mean(Final_Data2$error^2))

Nous voyons que «rmse2» est légèrement inférieur à «rmse1» et que le deuxième modèle est donc légèrement meilleur que le premier modèle.

Classification:

Nous travaillerons avec l'ensemble de données 'car_purchase' à mettre en œuvre partitionnement récursif qui est un algorithme de classification.

Divisons les données en ensembles «train» et «test» à l'aide de la fonction «sample.split ()» du package «caTools».

bibliothèque (caTools)

65% des observations de la colonne «Acheté» se verront attribuer des étiquettes «VRAI» et les autres se verront attribuer des étiquettes «FAUX».

sample.split (car_purchase $ Acheté, SplitRatio = 0,65) -> split_values

Toutes les observations portant l’étiquette «VRAI» seront stockées dans les données «train» et les observations portant l’étiquette «FAUX» seront affectées aux données de «test».

sous-ensemble (achat_de_voiture, valeurs_partagées == T) -> train_data
sous-ensemble (achat_de_voiture, valeurs_partagées == F) -> test_data

Il est temps de créer l'algorithme de partitionnement récursif:

Nous allons commencer par charger le package 'rpart':

bibliothèque (rpart)

La colonne «Acheté» sera la variable dépendante et toutes les autres colonnes sont les variables indépendantes, c'est-à-dire que nous déterminons si la personne a acheté la voiture ou non par rapport à toutes les autres colonnes. Le modèle est construit sur «train_data» et le résultat est stocké dans «mod1».

rpart (Acheté ~., data = train_data) -> mod1

Tracons le résultat:

tracé (mod1, marge = 0,1) texte (mod1, joli = T, cex = 0.8)

Maintenant, allons-y et prédisons les résultats sur 'test_data'. Nous donnons le modèle rpart construit «mod1» comme premier argument, l'ensemble de test «test_data» comme deuxième argument et le type de prédiction comme «classe» pour le troisième argument. Le résultat est stocké dans l’objet ‘result1’.

prédire (mod1, test_data, type = 'class') -> résultat1

Évaluons la précision du modèle à l'aide de la fonction 'confusionMatrix ()' du package caret.

bibliothèque (caret) confusionMatrix (table (test_data $ Acheté, résultat1))

La matrice de confusion nous dit que sur les 90 observations où la personne n'a pas acheté la voiture, 79 observations ont été classées à juste titre comme «non» et 11 ont été classées à tort comme «OUI». De même, sur les 50 observations où la personne a effectivement acheté la voiture, 47 ont été à juste titre classées «OUI» et 3 ont été classées à tort comme «NON».

comment convertir double en int en java

Nous pouvons trouver la précision du modèle en divisant les prédictions correctes par les prédictions totales, c'est-à-dire (79 + 47) / (79 + 47 + 11 + 3).

Clustering K-Means:

Nous travaillerons avec l'ensemble de données 'iris' pour mettre en œuvre le clustering k-means:

Supprimons la colonne 'Espèces' et créons un nouvel ensemble de données qui comprend uniquement les quatre premières colonnes de l'ensemble de données 'iris'.

iris [1: 4] -> iris_k

Prenons le nombre de clusters à 3. La fonction «Kmeans ()» prend les données d'entrée et le nombre de clusters dans lesquels les données doivent être regroupées. La syntaxe est la suivante: kmeans (données, k) où k est le nombre de centres de cluster.

kmeans (iris_k, 3) -> k1

Analyse du clustering:

str (k1)

La fonction str () donne la structure des kmeans qui comprend divers paramètres comme withinss, betweenss, etc., en analysant ce qui vous permet de connaître les performances des kmeans.

entre les deux: entre la somme des carrés, c'est-à-dire la similarité intracluster

withinss: Dans la somme des carrés, c'est-à-dire similitude intercluster

totwithinss: somme de tous les inins de tous les clusters, c'est-à-dire similarité intra-cluster totale

Un bon regroupement aura une valeur inférieure de «tot.withinss» et une valeur plus élevée de «betweenss» qui dépend du nombre de clusters «k» choisi initialement.

Le moment est venu de devenir un expert en apprentissage automatique afin de profiter des nouvelles opportunités qui se présentent à vous. Cela nous amène à la fin de cette ' Apprentissage automatique avec R ' Blog. J'espère que ce blog a été instructif et fructueux.

Edureka a une qui vous aide à acquérir une expertise dans les algorithmes d'apprentissage automatique tels que le clustering K-Means, les arbres de décision, la forêt aléatoire, Naive Bayes. Vous apprendrez les concepts de statistiques, de séries chronologiques, d'exploration de texte et une introduction au Deep Learning. De nouveaux lots pour ce cours commencent bientôt !!