Machine Learning” avec R – Modèles supervisés –

Introduction

Ce tutoriel est basé sur celui de de Saba Tavoosi (https://www.kaggle.com/tavoosi) que j’ai traduit en français, corrigé (car certaines valeurs ont évoluées) et complété

Dans ce tutoriel, nous utiliserons l’ensemble de données iris afin de créer un guide simple pour les débutants, ligne par ligne, de 4 différents modèles de classification par apprentissage automatique supervisé dans le but de prédire les espèces d’iris en fonction d’un ensemble de variables. Il s’agit d’un guide simple et facile pour les débutants qui s’initient à l’apprentissage automatique. Nous apprendrons à créer les modèles suivants :

• Decision Trees / Arbres de décision
  
• Random Forests / Forets àléatoires
  
• Naive Bayes
  
• Support Vector Machines / Support Vector Machine (SVM)

La création de modèles d’apprentissage automatique implique généralement les processus suivants :

1. Analyse exploratoire des données - exploration des données pour trouver des modèles importants et pour aider à l’ingénierie des fonctionnalités.
2. Ingénierie des caractéristiques - créer de nouvelles variables à partir de celles qui existent déjà.
   
3. Gestion des valeurs manquantes - décider de ce qu’il faut faire avec les valeurs manquantes dans les données. 4.
   
4. Apprentissage automatique - créer un modèle prédictif.
   
5. Prédiction - utiliser le modèle d’apprentissage automatique pour faire des prédictions.

En général, les étapes 1 à 3 sont les plus longues, tandis que la création du modèle prend beaucoup moins de temps. Pour les besoins de ce tutoriel, nous allons ignorer l’ingénierie des caractéristiques et le traitement des valeurs manquantes, car ces étapes ne sont pas nécessaires avec nos données. Cependant, avec les données du monde réel, ces étapes sont généralement nécessaires et constituent également une partie importante du processus. Si vous souhaitez en savoir plus sur ces deux étapes, vous pouvez consulter le tutoriel [Predicting survival on the Titanic] (https://www.kaggle.com/tavoosi/predicting-survival-on-the-titanic-with-rf-lr-nb).

Charger les paquets nécessaires

Tout d’abord, nous allons charger tous les paquets que nous utiliserons pour nos analyses.

library(ggplot2) # Visualisation graphique des données
library(plotly) # Graphiques interactifs
library(psych) # Utiliser pour la visualisation du la matrix de correlation
library(rattle) # utilisé pour l'arbre de decisions
library(caret) # Package de Machine Learning
library(party) #tracé arbre inférence conditionnelle

Chargez l’ensemble de données de l’iris. Ce jeu de données fait partie des jeux de données de base intégrés dans R, nous n’avons donc pas besoin de le charger en externe.

data("iris")

Coup d’oeil sur les données

Vérifions les 6 premières lignes ainsi que les statistiques récapitulatives de nos données pour avoir une idée de l’aspect des données.

head

head(iris)

  Sepal.Length Sepal.Width Petal.Length Petal.Width Species
1          5.1         3.5          1.4         0.2  setosa
2          4.9         3.0          1.4         0.2  setosa
3          4.7         3.2          1.3         0.2  setosa
4          4.6         3.1          1.5         0.2  setosa
5          5.0         3.6          1.4         0.2  setosa
6          5.4         3.9          1.7         0.4  setosa

Summary

summary(iris)

  Sepal.Length    Sepal.Width     Petal.Length    Petal.Width   
 Min.   :4.300   Min.   :2.000   Min.   :1.000   Min.   :0.100  
 1st Qu.:5.100   1st Qu.:2.800   1st Qu.:1.600   1st Qu.:0.300  
 Median :5.800   Median :3.000   Median :4.350   Median :1.300  
 Mean   :5.843   Mean   :3.057   Mean   :3.758   Mean   :1.199  
 3rd Qu.:6.400   3rd Qu.:3.300   3rd Qu.:5.100   3rd Qu.:1.800  
 Max.   :7.900   Max.   :4.400   Max.   :6.900   Max.   :2.500  
       Species  
 setosa    :50  
 versicolor:50  
 virginica :50  
                
                
                

Analyse exploratoire des données

Effectuons une analyse exploratoire des données afin d’étudier visuellement nos données et d’y trouver des modèles et des informations. Cette étape peut nous aider à mieux comprendre les données et nous préparer à créer notre modèle plus tard.

Correlation matrix

Créons une matrice de corrélation en utilisant la fonction pairs.panels() du paquet PSYCH pour voir comment nos variables sont corrélées.

pairs.panels(
       iris[,1:4], # les données.
       scale = TRUE, # adaptatoin automatique de l'echelle.
       hist.col = 'grey85', # couleur de l'histogramme.  
       bg = c('#BF382A', '#0C4B8E',"#006600")[iris$Species], # Couleurs des différentes espè.
       pch = 21, # taille et forme des polices du graphique.
       main = 'Correlation matrix of Iris data')  # Titre. 

La partie supérieure de la matrice de corrélation nous indique la corrélation entre les variables et nous pouvons voir qu’il existe une corrélation modérée à forte entre toutes les variables, sauf entre la longueur du sépale et la largeur du sépale. L’examen de la moitié inférieure de la matrice nous donne un aperçu supplémentaire non seulement des diagrammes de dispersion de ces corrélations, mais divise également les points de données par espèce d’iris en utilisant des couleurs. Cela nous permet de voir les groupes qui sont présents parmi les espèces.

3D plot

Nous allons maintenant créer un nuage de points interactif en 3D en utilisant plot_ly() du package PLOTLY.

Comme notre graphique 3D est, eh bien, tridimensionnel, nous ne pouvons lui fournir que 3 variables pour les axes. Comme nous avons 4 variables, j’ai décidé d’exclure la largeur des sépales de notre graphique car elle semble être la variable la moins importante quand on regarde les variables individuelles (que nous pouvons voir dans les onglets 3-6).

plot_ly(data = iris,  # données
        x = ~Sepal.Length, y = ~Petal.Length, z = ~Petal.Width,  # X, Y, and Z variables. Put a tilde sign (~) before each variable name.
        color = ~Species,  # couleurs différenciées par espèces. 
        type = "scatter3d",  # graphique 3D.
        colors = c('#BF382A', "#006600",'#0C4B8E'),
        mode = "markers", # mode "markers". 
        size = 4
        ) %>%  # Pipe
        layout(
               scene = list(xaxis = list(title = 'Sepal length'), # noms des axes. 
                            yaxis = list(title = 'Petal length'),
                            zaxis = list(title = 'Petal width')))

Ce graphique est très efficace pour nous montrer où se situent nos espèces sur les 3 variables, ce qui permet d’évaluer plus facilement à quel point elles sont proches/éloignées les unes des autres. Nous pouvons, par exemple, voir que les données de setosa se trouvent dans un groupe assez isolé, tandis que versicolor et virginica, bien que se trouvant également dans des groupes assez clairs, montrent un léger chevauchement. Ces groupes distincts sont un bon signe pour notre apprentissage automatique ultérieur, car ils devraient aider notre modèle à faire de bonnes prédictions.

Sepal width

Box plot of sepal width:

ggplot(
       # (1) Set data; (2) Specify X and Y variables; (3) 'fill' color separates our Species levels.
       data = iris, mapping = aes(x = Species, y = Sepal.Width, fill = Species), palette =c('#BF382A', '#0C4B8E',"#006600")) +
       geom_boxplot() +  # format boxplot. 
         # couleurs utilisées pourle boxplot. 
       theme_light() +  # thème. 
       labs(title = 'Box plot of sepal width for each species', 
            x = 'Species', y = 'Sepal width')  # titre du graphique et des axes.

Ce diagramme en boîte montre que l’espèce setosa a une largeur de sépale médiane et un écart interquartile plus élevés que les deux autres espèces. En revanche, les espèces Versicolor et Virginica présentent un chevauchement important en termes d’écart interquartile. Il sera donc plus difficile pour un algorithme d’apprentissage automatique de distinguer les deux niveaux d’espèces lors de la prédiction à l’aide de cette variable.

Sepal length

(Pour une explication détaillée de la manière de créer le box plot, consultez le troisième onglet).

Box plot of sepal length:

ggplot(data = iris, mapping = aes(x = Species, y = Sepal.Length, fill = Species), palette = c('#BF382A', '#0C4B8E',"#006600")) +
       geom_boxplot() + 
        theme_light() +
       labs(title = 'Box plot of sepal length for each species', 
            x = 'Species', y = 'Sepal length')

Les intervalles des trois espèces semblent se chevaucher quelque peu sur la variable de la longueur des sépales. Cependant, leurs médianes semblent différer (du moins visuellement. Nous ne savons pas si elles sont statistiquement significativement différentes - nous pourrions le tester, mais ce n’est pas nécessaire pour les besoins de ce noyau).

Petal width

(Pour une explication détaillée de la manière de créer le box plot, consultez le troisième onglet).

Box plot of petal width:

ggplot(data = iris, mapping = aes(x = Species, y = Petal.Width, fill = Species), palette = c('#BF382A', '#0C4B8E',"#006600")) + 
       geom_boxplot() + 
       theme_light() +
       labs(title = 'Box plot of petal width for each species', 
            x = 'Species', y = 'Petal width')

Ce diagramme en boîte semble indiquer une grande différence dans la largeur des pétales entre les espèces

Petal length

(Pour une explication détaillée de la manière de créer le box plot, consultez le troisième onglet).

Box plot of petal length:

ggplot(data = iris, mapping = aes(x = Species, y = Petal.Length, fill = Species), palette =c('#BF382A', '#0C4B8E',"#006600")) +
       geom_boxplot() + 
       theme_light() +
       labs(title = 'Box plot of petal length for each species', 
            x = 'Species', y = 'Petal length')

Ce graphique semble indiquer que les trois espèces varient en termes d’écart interquartile sur la longueur des pétales. Le setosa semble avoir un écart interquartile très étroit et une longueur de pétale beaucoup plus courte que les deux autres espèces.

Partitionnement des données

Avant de commencer à former notre modèle d’apprentissage automatique, nous devons diviser notre ensemble de données en sous-ensembles de formation et de test. L’ensemble de données d’entraînement est utilisé pour apprendre ou “former” notre modèle d’apprentissage automatique à faire des prédictions avec nos données, tandis que l’ensemble de données de test est utilisé pour tester notre modèle sur des données qu’il n’a pas vues afin de voir comment il se comporte.

Tout d’abord, définissons une graine aléatoire. Cela nous permettra de nous assurer que nous serons en mesure de reproduire nos résultats lorsque nous réexécuterons notre analyse.

set.seed(222)

Ensuite, nous allons créer une partition train/test avec createDataPartition() du package CARET. Cela va diviser nos données par un échantillonnage aléatoire dans nos niveaux d’espèces et nous donner l’indice échantillonné.

train_index <- createDataPartition(y = iris$Species,  # y = our dependent variable.
                                   p = .7,  # Specifies split into 70% & 30%.
                                   list = FALSE,  # Sets results to matrix form. 
                                   times = 1)  # Sets number of partitions to create to 1. 

Maintenant, nous pouvons diviser nos données en données de formation et de test en utilisant l’échantillon aléatoire train_index que nous venons de former.

train_data <- iris[train_index,]  # Use train_index of iris data to create train_data.
test_data <- iris[-train_index,]  # Use whatever that is not in train_index to create test_data.

Apprentissage automatique

Il est enfin temps de créer nos modèles d’apprentissage automatique afin de prédire à quelle catégorie d’espèces (setosa, versicolor, virginica) appartient chaque fleur d’iris. Nous allons procéder à un apprentissage automatique supervisé car les données que nous utilisons pour entraîner nos algorithmes incluent les espèces auxquelles les fleurs d’iris appartiennent (c’est-à-dire qu’elles incluent les réponses). L’opposé serait un apprentissage non supervisé, où la machine ne reçoit pas de réponses sur lesquelles s’entraîner. En outre, les algorithmes que nous utilisons sont des classificateurs, ce qui signifie qu’ils prédisent à quelle catégorie l’espèce appartient. L’opposé de cela serait la régression où l’on prédit des variables continues.

Pour des raisons de facilité et de simplicité, les modèles sont séparés en différents onglets indépendants afin que vous puissiez choisir celui que vous souhaitez examiner.

Arbre de décision

Quelques faits :

Utilisations: classification et régression
* Un arbre de décision utilise des variables d’entrée pour créer des branches de décisions pour finalement dériver une prédiction. La figure 1 donne une visualisation facile à comprendre de ce processus. Gardez à l’esprit que les arbres de décision de la vie réelle ont tendance à être plus grands et plus complexes que cela.
* Pros: (1) facile à interpréter, (2) peut traiter des données numériques et catégorielles, (3) bon pour traiter les valeurs aberrantes, (3) n’a pas d’hypothèses concernant les données (par exemple, la distribution des données). * (1) peut être surajusté aux données de formation, (2) sensible à la variance, de sorte que de petites différences d’entrée peuvent donner lieu à des modèles de prédiction différents.

Figure 1: Visualization of decision tree model.
Image source: [Link](https://blog.somostera.com/data-science/arvores-de-decisao

Modéliser le modèle d’arbre de décision avec une validation croisée 10 fois.

fitControl <- trainControl(method = "cv", number = 10, savePredictions = TRUE)

Créez un modèle prédicteur avec la fonction train() du package CARET. Spécifiez method = 'rpart' pour exécuter un modèle d’arbre de décision.

# Create model
dt_model <- train(Species ~ ., # Set Y variable followed by '~'. The period indicates to include all variables for prediction. 
                     data = train_data, # Data
                     method = 'rpart', # Specify SVM model
                     trControl = fitControl) # Use cross validation

Vérifiez la précision prédite de notre modèle d’arbre de décision en l’exécutant sur des rééchantillons de nos données d’entraînement. Plus tard, nous testerons la précision du modèle en effectuant une prédiction sur nos données de test.

confusionMatrix(dt_model)

Cross-Validated (10 fold) Confusion Matrix 

(entries are percentual average cell counts across resamples)
 
            Reference
Prediction   setosa versicolor virginica
  setosa       33.3        0.0       0.0
  versicolor    0.0       29.5       5.7
  virginica     0.0        3.8      27.6
                            
 Accuracy (average) : 0.9048

Les résultats ici nous indiquent que notre précision moyenne est de 90,48 % lorsque nous testons nos données sur des rééchantillons de nos données d’entraînement. Nous pouvons également voir ce qui a été prédit correctement/incorrectement.

Vérifiez l’importance de chaque caractéristique dans notre modèle.

# Create object of importance of our variables 
dt_importance <- varImp(dt_model)

# Create plot of importance of variables
ggplot(data = dt_importance, mapping = aes(x = dt_importance[,1])) + # Data & mapping
  geom_boxplot() + # Create box plot
  geom_bar(stat="identity", fill="lightblue", colour="black")+
   labs(title = "Variable importance: Decision tree model") + # Title
  theme_light() # Theme

Ce tableau nous donne un aperçu très informatif de l’importance de chaque variable dans la prédiction de l’espèce.

Traçons maintenant l’arbre de décision en utilisant fancyRpartPlot() du paquetage RATTLE. Cela nous donnera un aperçu clair de la façon dont le modèle fait ses prédictions.

fancyRpartPlot(dt_model$finalModel, sub = '',type = 2)

Cet arbre de décision nous dit que :

• Si la longueur des pétales est inférieure à 2,6, la prédiction est setosa.
• Si la longueur des pétales est comprise entre 2,6 et 4,8, la prédiction est versicolor.
• Si la longueur des pétales est supérieure à 4,8, la prédiction est virginica.

Comme nous pouvons le constater, la longueur des pétales est la seule variable nécessaire pour faire ces prédictions.

PRÉDICTION : modèle d’arbre de décision

Utilisez le dt_model créé pour effectuer une prédiction sur les données de test.

prediction_dt <- predict(dt_model, test_data)

Vérifiez la proportion des prédictions qui étaient exactes.

table(prediction_dt, test_data$Species) %>% # Create prediction table. 
  prop.table() %>% # Convert table values into proportions instead of counts. 
  round(2) # Round numbers to 2 significant values. 

             
prediction_dt setosa versicolor virginica
   setosa       0.33       0.00      0.00
   versicolor   0.00       0.31      0.00
   virginica    0.00       0.02      0.33

Comme on peut le voir, 98% des classifications d’espèces ont été prédites correctement.

• Exactitude finale du modèle d’arbre de décision : 98%

Random forest / Forêt aléatoire

Quick facts:

Utilisations: classification et régression
* La forêt aléatoire fonctionne en créant de nombreux arbres de décision, puis en calculant la moyenne de leurs résultats pour obtenir une prédiction. Pour les problèmes de classification, cette moyenne sera le mode, tandis que pour les problèmes de régression, ce sera la moyenne. Voir Figure 2 pour une visualisation de ce processus.
Pros: (1) bon contre l’overfitting (en raison de sa moyenne à travers de nombreux arbres de décision), (2) bon pour traiter les valeurs aberrantes, (3) peut traiter les données numériques et catégorielles, (4) flexible.
**Cons : (1) difficile à interpréter, (2) peut prendre beaucoup de temps par rapport à certains autres modèles.

Figure 2: Visualization of random forest model.
Image source: Link

Créez un objet pour une validation croisée 10 fois. Nous allons l’utiliser dans notre fonction train() pour définir trControl ensuite.

fitControl <- trainControl(method = "cv", number = 10, savePredictions = TRUE)

Créez un modèle d’entraînement en utilisant train() du paquet CARET.

# Create model
rf_model <- train(
                  Species ~ .,  # Set Y variable followed by "~." to include all variables in formula.
                  method = 'rf',  # Set method as random forest.
                  trControl = fitControl,  # Set cross validation settings
                  data = train_data)  # Set data as train_data. 

Utilisez la fonction varImp() pour récupérer l’importance de chaque variable dans notre modèle de forêt aléatoire et ensuite les tracer.

# Create object of importance of our variables 
rf_importance <- varImp(rf_model) 

# Create box plot of importance of variables
ggplot(data = rf_importance, mapping = aes(x = rf_importance[,1])) + # Data & mapping
  geom_boxplot() + # Create box plot
  geom_bar(stat="identity", fill="lightblue", colour="black")+
  labs(title = "Variable importance: Random forest model") + # Title
  theme_light() # Theme

Ce graphique nous indique que la longueur et la largeur des pétales sont les variables les plus importantes pour la prédiction dans notre modèle.

Maintenant, vérifions la précision de la prédiction du modèle de forêt aléatoire en l’exécutant sur des rééchantillons de nos données d’entraînement. Plus tard, nous testerons la précision du modèle en effectuant une prédiction sur nos données de test, qui sont des données que notre modèle n’a jamais vues auparavant.

confusionMatrix(rf_model)

Cross-Validated (10 fold) Confusion Matrix 

(entries are percentual average cell counts across resamples)
 
            Reference
Prediction   setosa versicolor virginica
  setosa       33.3        0.0       0.0
  versicolor    0.0       29.5       2.9
  virginica     0.0        3.8      30.5
                            
 Accuracy (average) : 0.9333

La sortie nous indique que la précision prédite de notre modèle est de 93,33%. En outre, il nous donne également une matrice de pourcentage des prédictions des espèces par rapport aux réponses.

Prédiction : Modèle de forêt aléatoire

Nous allons maintenant utiliser le modèle de forêt aléatoire que nous avons créé afin de prédire les espèces sur nos données de test (c’est-à-dire l’ensemble de données que notre “machine” n’a jamais vu auparavant).

Utilisez le rf_model créé pour effectuer une prédiction sur les données de test.

prediction_rf <- predict(rf_model, test_data)

Vérifiez la précision de notre modèle de forêt aléatoire sur nos données de test.

table(prediction_rf, test_data$Species) %>% # Create prediction table. 
  prop.table() %>% # Convert table values into proportions instead of counts. 
  round(2) # Round numbers to 2 significant values. 

             
prediction_rf setosa versicolor virginica
   setosa       0.33       0.00      0.00
   versicolor   0.00       0.33      0.00
   virginica    0.00       0.00      0.33

100 % des classifications d’espèces ont été prédites correctement ! Il est important de noter que ce type de précision est rarement observé avec les données du monde réel qui sont généralement beaucoup plus complexes que notre ensemble de données sur l’iris.

• Précision finale du modèle Random Forest : 100%

Naive Bayes

Quick facts:

Utilisations: classification
* Comment ça marche: Le modèle Naive Bayes est un algorithme de classification simple basé sur le théorème de Bayes. Il suppose naïvement que toutes les caractéristiques qui lui sont fournies sont indépendantes les unes des autres et qu’elles ont la même importance pour prédire le résultat. Malgré sa simplicité, il peut être plus efficace que certains algorithmes plus avancés.
Pros: (1) nécessite peu de données pour la formation, (2) utile pour les grands ensembles de données, (3) relativement rapide.
Conséquences: (1) suppose que les caractéristiques sont indépendantes et égales, ce qui n’est généralement pas le cas dans la vie réelle.

Figure 3: Bayes’ theorem.
Image source: Link

Modélisation du modèle Naive Bayes avec une validation croisée 10 fois.

fitControl <- trainControl(method = "cv", number = 10, savePredictions = TRUE)

Créez un modèle prédicteur avec la fonction train() du package CARET. Spécifiez method = 'nb' pour exécuter un modèle Naive Bayes.

# Create model
nb_model <- train(Species ~ ., # Set y variable followed by '~'. The period indicates that we want to use all our variables for prediction.
                     data = train_data,
                     method = 'nb', # Specify Naive Bayes model
                     trControl = fitControl) # Use cross validation

Vérifiez la précision de la prédiction de notre modèle en l’exécutant sur des rééchantillons de nos données d’entraînement. Plus tard, nous testerons la précision du modèle en effectuant une prédiction sur nos données de test.

confusionMatrix(nb_model)

Cross-Validated (10 fold) Confusion Matrix 

(entries are percentual average cell counts across resamples)
 
            Reference
Prediction   setosa versicolor virginica
  setosa       33.3        0.0       0.0
  versicolor    0.0       29.5       2.9
  virginica     0.0        3.8      30.5
                            
 Accuracy (average) : 0.9333

Les résultats ici nous indiquent que notre précision moyenne est de 93.33 % lorsque nous testons nos données sur des rééchantillons de nos données de formation. Nous pouvons également voir ce qui a été prédit correctement/incorrectement.

Utilisez la fonction varImp() pour récupérer l’importance de chaque variable dans notre modèle de forêt aléatoire et ensuite les tracer.

# Create object of importance of our variables 
nb_importance <- varImp(nb_model) 

# Create box plot of importance of variables
ggplot(data = nb_importance, mapping = aes(x = nb_importance[,1])) + # Data & mapping
  geom_boxplot() + # Create box plot
  labs(title = "Variable importance: Naive Bayes model") + # Title
  theme_light() # Theme

Ce tableau nous donne un aperçu très instructif de l’importance de chaque variable dans la prédiction de chaque espèce. Nous pouvons constater que la largeur et la longueur des pétales sont les deux variables les plus importantes pour prédire chaque espèce.

PREDICTION : Modèle Naive Bayes

Utilisez le nb_model créé pour effectuer une prédiction sur les données de test.

prediction_nb <- predict(nb_model, test_data)

Vérifiez la proportion des prédictions qui étaient exactes.

table(prediction_nb, test_data$Species) %>% # Create prediction table. 
  prop.table() %>% # Convert table values into proportions instead of counts. 
  round(2) # Round numbers to 2 significant values. 

             
prediction_nb setosa versicolor virginica
   setosa       0.33       0.00      0.00
   versicolor   0.00       0.31      0.00
   virginica    0.00       0.02      0.33

Ici, nous pouvons voir que 98% des classifications d’espèces ont été prédites correctement.

• Précision finale du modèle Naive Bayes : 98%

Support Vector Machine (SVM)

Quick facts:

Utilisations: classification et régression
* On peut conceptualiser le SVM en pensant à un graphique où une dimension est ajoutée pour chaque caractéristique des données. Tous les points de données sont alors tracés dans cet espace à n dimensions. Les SVM classent ensuite les données en créant des hyperplans optimaux qui divisent les données en différentes catégories. La figure 4 ci-dessous donne une visualisation de ce processus pour des données avec deux caractéristiques dans un espace à 2 dimensions.
Pros: (1) efficace lorsque les catégories peuvent être bien divisées par des hyperplans, (2) bon pour traiter les valeurs aberrantes.
* (1) peut prendre beaucoup de temps lorsqu’il y a beaucoup de données, (2) n’est pas aussi performant lorsque les catégories se chevauchent (ce qui rend plus difficile la division des catégories par les hyperplans).

Figure 4: Support vector machine hyperplane representation.
Image source: Link

Modéliser le modèle SVM avec une validation croisée 10 fois.

fitControl <- trainControl(method = "cv", number = 10, savePredictions = TRUE)

Créez un modèle prédicteur avec la fonction train() du package CARET. Spécifiez method = 'svmLinear' pour exécuter un modèle SVM..

# Create model
svm_model <- train(Species ~ ., # Set Y variable followed by '~'. The period indicates to include all variables for prediction. 
                     data = train_data, # Data
                     method = 'svmLinear', # Specify SVM model
                     trControl = fitControl) # Use cross validation

Vérifiez la précision prédite de notre modèle Bayes naïf en l’exécutant sur des rééchantillons de nos données d’entraînement. Plus tard, nous testerons la précision du modèle en effectuant une prédiction sur nos données de test.a*.

confusionMatrix(svm_model)

Cross-Validated (10 fold) Confusion Matrix 

(entries are percentual average cell counts across resamples)
 
            Reference
Prediction   setosa versicolor virginica
  setosa       33.3        0.0       0.0
  versicolor    0.0       28.6       1.0
  virginica     0.0        4.8      32.4
                            
 Accuracy (average) : 0.9429

Les résultats ici nous indiquent que notre précision moyenne est de 94.29% lorsque nous testons nos données sur des rééchantillons de nos données d’entraînement. Nous pouvons également voir ce qui a été prédit correctement/incorrectement.

Utilisez la fonction varImp() pour récupérer l’importance de chaque variable dans notre modèle de forêt aléatoire et ensuite les tracer.

# Create object of importance of our variables 
svm_importance <- varImp(svm_model)

# Create box plot
ggplot(data = svm_importance, mapping = aes(x = svm_importance[,1])) + # Data & mapping
  geom_boxplot() + # Create box plot
  labs(title = "Variable importance: Support vector machine model") + # Title
  theme_light() # Theme

Ce tableau nous donne un aperçu très instructif de l’importance de chaque variable dans la prédiction de chaque espèce. Nous pouvons voir que la longueur et la largeur des pétales sont les deux variables les plus importantes pour prédire chaque espèce.

PREDICTION : Machine à vecteur de support

Utilisez le svm_model créé pour effectuer une prédiction sur les données de test.

prediction_svm <- predict(svm_model, test_data)

Vérifiez la proportion des prédictions qui étaient exactes.

table(prediction_svm, test_data$Species) %>% # Create prediction table. 
  prop.table() %>% # Convert table values into proportions instead of counts. 
  round(2) # Round numbers to 2 significant values. 

              
prediction_svm setosa versicolor virginica
    setosa       0.33       0.00      0.00
    versicolor   0.00       0.33      0.00
    virginica    0.00       0.00      0.33

100% des classifications d’espèces ont été prédites correctement. Bravo !

• Précision finale du modèle de machine à vecteur de support : 100%

Modèle mixte

Prévision de la classe d’iris par les dimensions des sépales et des pétales

library(party)
tree<- ctree(Species ~ . , data=iris)
plot(tree)

Nous avons ici l’arbre de décision qui inclut les quatre variables (longueur du sépale, largeur du sépale, longueur du pétale et largeur du pétale) dans le modèle de prédiction.

Remarquez qu’il n’y a que deux facteurs qui sont utilisés dans les nœuds de décision : la longueur du pétale et la largeur du pétale. Cela nous indique que ces deux facteurs sont les plus importants pour distinguer à quel type de classe d’iris appartient chaque fleur. Les facteurs longueur du sépale et largeur du sépale ne sont pas nécessaires pour prédire à quelle classe appartiennent les fleurs.

Réseau de neurones

dessiner un boxplot pour voir si l’ensemble de données doit être mis à l’échelle et s’il y a des valeurs aberrantes. À cette fin, créer une fonction pour dessiner des boxplots.

library(tidyverse)
library(scales)
data("iris")
iris <- iris %>% 
  mutate(Species=as_factor(Species) )

draw_boxplot <- function(){
  iris %>% 
    pivot_longer(1:4, names_to="attributes") %>% 
    ggplot(aes(attributes, value, fill=attributes)) +
    geom_boxplot()
}

La méthode pivot_longer fait pivoter les colonnes d’éléments en lignes de sorte que nous nous retrouvions avec une colonne contenant les noms des colonnes d’éléments et leurs valeurs respectives. Nous passons ensuite la colonne des noms comme axe des x et la colonne des valeurs comme axe des y de la fonction ggplot. Enfin, nous utilisons la méthode geom_boxplot pour dessiner le boxplot. Ensuite, appelez la méthode draw_boxplot pour dessiner un boxplot.

draw_boxplot()

Nous pouvons observer que les colonnes ont des échelles différentes et que la colonne ‘Sepal.Width’ présente des valeurs aberrantes. Tout d’abord, éliminons les valeurs aberrantes. Je vais utiliser la méthode Squish pour éliminer les valeurs aberrantes. Notez que je ne vais pas supprimer les données aberrantes. Au lieu de cela, je vais seulement définir les lignes de données aberrantes à la valeur maximale ou minimale.

Cela va comprimer mes données entre le 95ème percentile et le 5ème percentile.

Maintenant, mettons également à l’échelle les colonnes en utilisant la méthode scale. La méthode d’échelle dans R utilise la normalisation du score Z pour normaliser les données.

Une fois encore, visualisons l’ensemble des données pour voir s’il y a des améliorations.

iris <- iris %>% 
  mutate(across(Sepal.Width, ~squish(.x, quantile(.x, c(0.05, 0.95)))))

iris <- iris %>% 
  mutate(across(1:4, scale))

draw_boxplot()

Nous pouvons voir que les colonnes ont une échelle similaire et qu’il n’y a pas de valeurs aberrantes. Excellent !

#Séparation de l’ensemble de données

Maintenant que nous avons terminé la tâche de prétraitement, nous allons diviser l’ensemble de données en données d’entraînement et en données de test. Nous utiliserons 70% des données comme données de formation et le reste comme données de test.

En divisant l’ensemble de données, nous devons nous assurer que les lignes sont réparties de manière aléatoire. Donc, commençons par générer un vecteur d’entiers aléatoires. Le nombre total d’entiers doit être égal à 70% du nombre total de lignes de l’ensemble de données.

library(neuralnet)
training_data_rows <- floor(0.70 * nrow(iris))         
set.seed(123)
training_indices <- sample(c(1:nrow(iris)), training_data_rows)

training_data <- iris[training_indices,]
test_data <- iris[-training_indices,]

neural.iris<- neuralnet(Species~Sepal.Length+Sepal.Width+Petal.Length+Petal.Width, 
             data=training_data, hidden=c(5), linear.output = FALSE)
plot(neural.iris)

predict <- function(data){
  prediction <- data.frame(neuralnet::compute(neural.iris, 
                                              data.frame(data[,-5]))$net.result)
  labels <- c("setosa", "versicolor", "virginca")
  prediction_label <- data.frame(max.col(prediction)) %>% 
    mutate(prediction=labels[max.col.prediction.]) %>% 
    select(2) %>% 
    unlist()

  table(data$Species, prediction_label)
}

Predicting Result

predict(training_data)%>% # Create prediction table. 
  prop.table() %>% # Convert table values into proportions instead of counts. 
  round(2)

            prediction_label
             setosa versicolor virginca
  setosa       0.34       0.00     0.00
  versicolor   0.00       0.30     0.00
  virginica    0.00       0.00     0.35

predict(test_data)%>% # Create prediction table. 
  prop.table() %>% # Convert table values into proportions instead of counts. 
  round(2)

            prediction_label
             setosa versicolor virginca
  setosa       0.31       0.00     0.00
  versicolor   0.00       0.38     0.02
  virginica    0.00       0.00     0.29

Comparaison des résultats

Tableau des résultats:

Models Machine learning	Précision prédiction	Précision test
Decision tree	90.48%	98%
Random Forest	93.33%	100%
Naive Bayes	93.33%	98%
Support Vector Machine	94.29%	100%
Modèle Mixte	…..%	…%
Neural Network	…..%	…%

Pour nos données, il semble que les modèles Random Forest / forêt aléatoire et Support Vector Machine / Séparteurs à vaste marge (SVM) aient donné les meilleurs résultats.

Contact : TOUZOT Benoit
Email :touzot.benoit.1417r@gmail.com

Pour aller plus loin…

Decision Trees
https://towardsdatascience.com/decision-trees-in-machine-learning-641b9c4e8052
https://medium.com/greyatom/decision-trees-a-simple-way-to-visualize-a-decision-dc506a403aeb

Random Forests
https://medium.com/@williamkoehrsen/random-forest-simple-explanation-377895a60d2d
https://www.stat.berkeley.edu/~breiman/RandomForests/cc_home.htm

Naive Bayes
https://www.analyticsvidhya.com/blog/2017/09/naive-bayes-explained/

Support Vector Machines
https://www.analyticsvidhya.com/blog/2017/09/understaing-support-vector-machine-example-code
https://towardsdatascience.com/support-vector-machines-svm-c9ef22815589

Neural Network
https://datascienceplus.com/neuralnet-train-and-test-neural-networks-using-r
https://www.thearmchaircritic.org/tech-journal/build-a-multi-class-classification-neural-network-in-r-in-fifty-lines-of-code