Machine learning

r – Prendre les décisions

Les structures décisionnelles exigent que le programmeur spécifie une ou plusieurs conditions devant être évaluées ou testées par le programme, ainsi qu’une ou plusieurs instructions à exécuter si la condition est déterminée comme étant vraie et éventuellement d’autres instructions à exécuter si la condition est déterminé comme étant fausse.

Voici la forme générale d’une structure décisionnelle typique trouvée dans la plupart des langages de programmation.

R fournit les types de décisions suivants. Cliquez sur les liens suivants pour vérifier leur détail.

if

Une instruction if est constituée d’une expression booléenne suivie d’une ou plusieurs instructions.

La syntaxe de base pour créer une instruction if dans R est :

If (boolean_expression) {
// instruction (s) s’exécutera si l’expression booléenne est vraie.
}

Si l’expression booléenne s’avère vraie, le bloc de code à l’intérieur de l’instruction if sera exécuté. Si l’expression booléenne s’avère fausse, le premier ensemble de code après la fin de l’instruction if (après l’accolade fermante) sera exécuté.

x <- 30L
if(is.integer(x)) {
print(« X est un entier »)
}

if …else

Une instruction if peut être suivie d’une instruction optionnelle else qui s’exécute lorsque l’expression booléenne est false.
Syntaxe

La syntaxe de base pour créer une instruction if … else dans R est :

If (boolean_expression) {
// instruction (s) s’exécutera si l’expression booléenne est vraie.
} else {
// instruction (s) s’exécutera si l’expression booléenne est false.
}

Si l’expression booléenne est évaluée comme étant vraie, alors le bloc de code if sera exécuté, sinon le bloc de code sera exécuté.

x <- c(« Que », »faire », »demain »)

if(« demain » %in% x) {
print(« demain est présent »)
} else {
print(« demain n’est pas présent »)
}

L’instruction if … else if … else

Une instruction if peut être suivie d’une instruction if else , qui est très utile pour tester diverses conditions en utilisant l’instruction if else if.

Syntaxe

La syntaxe de base pour créer une instruction if … else if … else dans R est

If (boolean_expression 1) {
    // Exécute lorsque l’expression booléenne 1 est vraie.
} Else if (expression_booléenne 2) {
    // Exécute quand l’expression booléenne 2 est vraie.
} Else if (expression_booléenne 3) {
    // Exécute lorsque l’expression booléenne 3 est vraie.
} else {
    // s’exécute lorsque aucune des conditions ci-dessus n’est vraie.
}

x <- c(« que », »faire », »demain »)

if(« demain » %in% x) {
   print(« demain est présent »)
} else if (« faire » %in% x) {
   print(« faire est présent »)
} else {
   print(« Ni faire, ni demain sont présents »)
}

switch

Une instruction switch permet à une variable d’être testée pour l’égalité par rapport à une liste de valeurs. Chaque valeur est appelée case, et la variable à activer est vérifiée pour chaque cas.
Syntaxe

La syntaxe de base pour créer une instruction switch dans R est

switch (expression, case1, case2, case3 ….)

Les règles suivantes s’appliquent à une instruction switch :

Si la valeur d’expression n’est pas une chaîne de caractères, elle est contrainte à l’entier.

Vous pouvez avoir n’importe quel nombre de déclarations de cas dans un commutateur. Chaque cas est suivi de la valeur à comparer et un :.

Si la valeur de l’entier est comprise entre 1 et nargs () – 1 (le nombre maximum d’arguments), l’élément correspondant de la condition de cas est évalué et le résultat renvoyé.

Si expression est évaluée à une chaîne de caractères, cette chaîne correspond exactement aux noms des éléments.

S’il y a plus d’une correspondance, le premier élément correspondant est renvoyé.

Aucun argument par défaut est disponible.

Dans le cas d’aucune correspondance, s’il y a un élément sans nom de … sa valeur est renvoyée. (S’il y a plusieurs arguments, une erreur est retournée.)

x <- switch(
   3,
   « first »,
   « second »,
   « third »,
   « fourth »
)

Les opérateurs

Un opérateur est un symbole qui indique au compilateur d’effectuer des manipulations mathématiques ou logiques spécifiques. R est riche en opérateurs intégrés et fournit les types suivants d’opérateurs.
Types d’opérateurs

Nous avons les types d’opérateurs suivants dans la programmation R –

– Opérateurs arithmétiques
– Opérateurs relationnels
– Opérateurs logiques
– Opérateurs d’affectation
– Opérateurs divers

Opérateurs arithmétiques

Le tableau suivant montre les opérateurs arithmétiques supportés par le langage R. Les opérateurs agissent sur chaque élément du vecteur.

+ additionne deux vecteurs
v <- c( 2,5.5,6)
t <- c(8, 3, 4)
print(v+t))

[1] 10.0  8.5 10.0

– soustrait deux vecteurs
v <- c( 2,5.5,6)
t <- c(8, 3, 4)
print(v-t)

[1] -6.0  2.5  2.0

* multiplier deux vecteurs
v <- c( 2,5.5,6)
t <- c(8, 3, 4)
print(v*t)

[1] 16.0 16.5 24.0

/ Diviser deux vecteurs
v <- c( 2,5.5,6)
t <- c(8, 3, 4)
print(v/t)

[1] 0.250000 1.833333 1.500000

%% Donner le reste du premier vecteur avec le second
v <- c( 2,5.5,6)
t <- c(8, 3, 4)
print(v%%t)

%/% Donner le reste de la division du premier vecteur par le second (quotient)
v <- c( 2,5.5,6)
t <- c(8, 3, 4)
print(v%/%t)

[1] 2.0 2.5 2.0

^ Le premier vecteur élevé à l’exposant du second vecteur
v <- c( 2,5.5,6)
t <- c(8, 3, 4)
print(v^t)

[1]  256.000  166.375 1296.000

Opérateurs relationnels

Le tableau suivant montre les opérateurs relationnels supportés par le langage R. Chaque élément du premier vecteur est comparé à l’élément correspondant du second vecteur. Le résultat de la comparaison est une valeur booléenne.

> Vérifie si chaque élément du premier vecteur est supérieur à l’élément correspondant du second vecteur.

v <- c(2,5.5,6,9)
t <- c(8,2.5,14,9)
print(v>t)

[1] FALSE  TRUE FALSE FALSE

< Vérifie si chaque élément du premier vecteur est inférieur à l’élément correspondant du second vecteur.

v <- c(2,5.5,6,9)
t <- c(8,2.5,14,9)
print(v<t)

[1]  TRUE FALSE  TRUE FALSE

== Vérifie si chaque élément du premier vecteur est égal à l’élément correspondant du second vecteur.
v <- c(2,5.5,6,9)
t <- c(8,2.5,14,9)
print(v == t)

[1] FALSE FALSE FALSE  TRUE

<= Vérifie si chaque élément du premier vecteur est inférieur ou égal à l’élément correspondant du second vecteur.
v <- c(2,5.5,6,9)
t <- c(8,2.5,14,9)
print(v<=t)

[1]  TRUE FALSE  TRUE  TRUE

>= Vérifie si chaque élément du premier vecteur est supérieur ou égal à l’élément correspondant du second vecteur.
v <- c(2,5.5,6,9)
t <- c(8,2.5,14,9)
print(v>=t)

[1] FALSE  TRUE FALSE  TRUE

!= Vérifie si chaque élément du premier vecteur est différent de l’élément correspondant du second vecteur.
v <- c(2,5.5,6,9)
t <- c(8,2.5,14,9)
print(v!=t)

[1]  TRUE  TRUE  TRUE FALSE

Opérateurs logiques

Le tableau suivant montre les opérateurs logiques pris en charge par le langage R. Il ne s’applique qu’aux vecteurs de type logique, numérique ou complexe. Tous les nombres supérieurs à 1 sont considérés comme valeur logique TRUE.

Chaque élément du premier vecteur est comparé à l’élément correspondant du second vecteur. Le résultat de la comparaison est une valeur booléenne.

& Elle est appelée opérateur logique ET élémentaire. Il combine chaque élément du premier vecteur avec l’élément correspondant du second vecteur et donne une sortie TRUE si les deux éléments sont TRUE.

v <- c(3,1,TRUE,2+3i)
t <- c(4,1,FALSE,2+3i)
print(v&t)

[1]  TRUE  TRUE FALSE  TRUE

| Il est appelé Opérateur logique élémentaire OU. Il combine chaque élément du premier vecteur avec l’élément correspondant du second vecteur et donne une sortie TRUE si l’un des éléments est TRUE.

v <- c(3,0,TRUE,2+2i)
t <- c(4,0,FALSE,2+3i)
print(v|t)

[1]  TRUE FALSE  TRUE  TRUE

! Il est appelé opérateur logique NOT. Prend chaque élément du vecteur et donne la valeur logique opposée.
v <- c(3,0,TRUE,2+2i)
print(!v)

[1] FALSE  TRUE FALSE FALSE

L’opérateur logique && et || Ne considère que le premier élément des vecteurs et donne un vecteur d’élément unique comme sortie.

&& Appelé Opérateur ET logique. Prend le premier élément des deux vecteurs et donne VRAI seulement si les deux sont VRAI.

v <- c(3,0,TRUE,2+2i)
t <- c(1,3,TRUE,2+3i)
print(v&&t)

[1] TRUE

|| Appelé Opérateur OU logique. Prend le premier élément des deux vecteurs et donne VRAI si l’un d’eux est VRAI.
v <- c(0,0,TRUE,2+2i)
t <- c(0,3,TRUE,2+3i)
print(v||t)

[1] FALSE

Opérateurs d’affectation

Ces opérateurs sont utilisés pour attribuer des valeurs aux vecteurs.

<− ou = ou <<− assignation à gauche
v1 <- c(3,1,TRUE,2+3i)
v2 <<- c(3,1,TRUE,2+3i)
v3 = c(3,1,TRUE,2+3i)
print(v1)
print(v2)
print(v3)

> print(v1)
[1] 3+0i 1+0i 1+0i 2+3i
> print(v2)
[1] 3+0i 1+0i 1+0i 2+3i
> print(v3)
[1] 3+0i 1+0i 1+0i 2+3i

−> ou −>> assignation à droite
c(3,1,TRUE,2+3i) -> v1
c(3,1,TRUE,2+3i) ->> v2
print(v1)
print(v2)

> print(v1)
[1] 3+0i 1+0i 1+0i 2+3i
> print(v2)
[1] 3+0i 1+0i 1+0i 2+3i

Opérateurs divers

Ces opérateurs sont utilisés pour des fins spécifiques et non pour des calculs mathématiques ou logiques généraux.

: Il crée la série de nombres en séquence pour un vecteur.
v <- 2:8
print(v)

[1] 2 3 4 5 6 7 8

%in% Cet opérateur permet d’identifier si un élément appartient à un vecteur.

v1 <- 8
v2 <- 12
t <- 1:10
print(v1 %in% t)
print(v2 %in% t)

> print(v1 %in% t)
[1] TRUE
> print(v2 %in% t)
[1] FALSE

%*% Cet opérateur est utilisé pour multiplier une matrice par sa transposition.
M = matrix( c(2,6,5,1,10,4), nrow = 2,ncol = 3,byrow = TRUE)
t = M %*% t(M)
print(t)

     [,1] [,2]
[1,]   65   82
[2,]   82  117

Les variables avec R

Une variable nous fournit un stockage nommé que nos programmes peuvent manipuler.
Une variable dans R peut stocker un vecteur atomique, un groupe de vecteurs atomiques ou une combinaison de plusieurs objets r. Un nom de variable valide se compose de lettres, de chiffres et des caractères point ou souligné. Le nom de la variable commence par une lettre ou le point n’est pas suivi d’un nombre.

Nom de la variable	Valide	Raison
var_name2.	valide	lettres, nombres, point et underscore
var_name%	Invalide	Le caractère ‘%’ n’est pas autorisé
2var_name	invalide	Commence par un nombre
.var_name , var.name	valide	On peut commencer par un point
.2var_name	invalide	On peut commencer par un point (.) mais on ne peut pas le faire suivre d’un chiffre.
_var_name	invalide	Commencer par un underscore n’est pas valide.

Affectation des variables

Les variables peuvent être affectées à l’aide de la gauche, de la droite et de l’opérateur (=). Les valeurs des variables peuvent être affichées à l’aide de la fonction print () ou cat (). La fonction cat () combine plusieurs éléments dans une sortie d’écran continue.

# Affectation en utilisant =.
var.1 = c(0,1,2,3)

# Affectation à gauche
var.2 <- c(« learn », »R »)

# Affectation à droite
c(TRUE,1) -> var.3

print(var.1)
cat (« var.1 is « , var.1 , »\n »)
cat (« var.2 is « , var.2 , »\n »)
cat (« var.3 is « , var.3 , »\n »)

Remarque – Le vecteur c (TRUE, 1) est un mélange de classe logique et numérique. Ainsi, la classe logique est contrainte à la classe numérique rendant VRAI comme 1.

Typage de variables

Dans R, une variable elle-même n’est pas déclarée d’un type de données, mais elle reçoit le type de données de l’objet R qui lui est affecté. Donc R est un langage typé dynamiquement, ce qui signifie que nous pouvons changer le type de données d’une variable par une autre variable encore et encore lorsque vous l’utilisez dans un programme.

var_x <- « Bonjour »
cat(« La classe de var_x est « ,class(var_x), »\n »)

var_x <- 34.5
cat( » La classe de var_x est « ,class(var_x), »\n »)

var_x <- 27L
cat( » La prochaine classe de var_x sera « ,class(var_x), »\n »)

La fonction ls () peut utiliser des modèles pour correspondre aux noms des variables.

# Liste des variables commençant par « var ».
print(ls(pattern = « var »))

Les variables commençant par point (.) sont cachées. Elles peuvent être listées en utilisant l’argument « all.names = TRUE » à la fonction ls ().
print(ls(all.name = TRUE))

Suppression des variables

Les variables peuvent être supprimées à l’aide de la fonction rm (). Ci-dessous, nous supprimons la variable var.3. Lors de l’impression, un message d’erreur est affiché.

rm(var.3)
print(var.3)

#Toutes les variables peuvent être supprimées en utilisant la fonction rm () et ls () #ensemble.
rm(list = ls())
print(ls())

R – Type de variables

Généralement, en programmant avec un langage de programmation, vous devez utiliser diverses variables pour stocker diverses informations. Les variables ne sont rien d’autre que des emplacements de mémoire réservés pour stocker des valeurs. Cela signifie que, lorsque vous créez une variable, vous réservez de l’espace en mémoire.

Vous pouvez avoir besoin de stocker des informations de divers types de données comme le caractère, caractère large, entier, virgule flottante, double virgule flottante, booléen, etc .. Basé sur le type de données d’une variable, le système d’exploitation alloue de la mémoire et décide ce qui peut être stocké en mémoire.

Contrairement à d’autres langages de programmation comme C et java dans R, les variables ne sont pas déclarées comme type de données. Les variables sont affectées à R-Objects et le type de données de l’objet R devient le type de données de la variable. Il existe de nombreux types d’objets R. Les plus fréquemment utilisés sont –

Vecteurs
Listes
Matrices
Tableaux
Facteurs
Cadres de données (Data Frame)

Le plus simple de ces objets est l’objet vectoriel et il existe six types de données de ces vecteurs atomiques, également appelés six classes de vecteurs. Les autres objets R sont construits sur les vecteurs atomiques.

Type de donnée	Exemple	Code R
Logique	TRUE, FALSE	v <- TRUE print(class(v)) retourne [1] "logical"
Numerique	12.3, 5, 999	v <- 23.5 print(class(v)) retourne [1] "numeric"
Entier	2L, 34L, 0L	v <- 2L print(class(v)) retourne [1] "integer"
Complexe	3 + 2i	v <- 2+5i print(class(v)) retourne [1] "complex"
Caractère	‘a’ , ‘ »bien », « TRUE », ‘23.4’	v <- "TRUE" print(class(v)) retourne [1] "character"
Raw	« Bonjour » est stocké à 48 65 6c 6c 6f	v <- charToRaw("Bonjour") print(class(v)) retourne [1] "raw"

Dans la programmation R, les types de données les plus élémentaires sont les objets R appelés vecteurs qui contiennent des éléments de classes différentes comme montré ci-dessus. Noter qu’en R le nombre de classes n’est pas limitée à seulement les six types ci-dessus. Par exemple, nous pouvons utiliser de nombreux vecteurs atomiques et créer un tableau dont la classe deviendra un tableau.

Vecteur

Lorsque vous voulez créer un vecteur avec plus d’un élément, vous devez utiliser la fonction c () qui indique que l’on combine les éléments dans un vecteur.

# Créer un vecteur.
pomme <- c(‘rouge’,’vert’, »jaune »)
print(pomme)

# Quelle est la classe de ce vecteur.
print(class(pomme))

Liste
Une liste est un objet R qui peut contenir plusieurs types d’éléments à l’intérieur, comme des vecteurs, des fonctions et même une autre liste à l’intérieur.

# Créer une liste.
list1 <- list(c(2,5,3),21.3,sin)

# Print the list.
print(list1)

Matrice
Une matrice est un ensemble de données rectangulaires bidimensionnelles. Elle peut être créée en utilisant une entrée vectorielle à la fonction matrice.

# Créer une matrice
M = matrix( c(‘a’,’a’,’b’,’c’,’b’,’a’), nrow = 2, ncol = 3, byrow = TRUE)
print(M)

Tableau
Alors que les matrices sont confinées à deux dimensions, les tableaux peuvent être de n’importe quel nombre de dimensions. La fonction array prend un attribut dim qui crée le nombre requis de dimension. Dans l’exemple ci-dessous nous créons un tableau avec deux éléments qui sont des matrices 3×3 chacune.

# Créer un tableau.
a <- array(c(‘vert’,’jaune’),dim = c(3,3,2))
print(a)

Les facteurs
Les facteurs sont des objets r qui sont créés à l’aide d’un vecteur. Il stocke le vecteur avec les valeurs distinctes des éléments dans le vecteur sous forme d’étiquettes. Les étiquettes sont toujours sous la forme de caractère, qu’il s’agisse d’un caractère numérique ou d’un caractère ou d’un caractère booléen, etc., dans le vecteur d’entrée. Ils sont utiles dans la modélisation statistique.

Les facteurs sont créés à l’aide de la fonction factor (). Les fonctions nlevels donnent le nombre de niveaux.

# Créer un vecteur.
couleur_pomme <- c(‘vert’,’vert’,’jaune’,’rouge’,’rouge’,’rouge’,’vert’)

# Créer un objet facteur.
factor_pomme <- factor(couleur_pomme)

# Affichages de facteur.
print(factor_pomme)
print(nlevels(factor_pomme))

Data Frames

Les data Frames sont des objets de données tabulaires. Contrairement à une matrice dans une trame de données, chaque colonne peut contenir différents modes de données. La première colonne peut être numérique tandis que la deuxième colonne peut être de caractère et la troisième colonne peut être logique. C’est une liste de vecteurs de longueur égale.
Les cadres de données sont créés à l’aide de la fonction data.frame ().

# Créer une data frame.
Typo<-    data.frame(
   gender = c(« Femme », « Homme », »Femme »),
   height = c(152, 171.5, 165),
   weight = c(81,93, 78),
   Age = c(42,38,26)
)
print(Typo)

Ce qu’il ne faut pas faire avec R

Voici ce que vous ne devriez PAS faire lorsque vous commencez à étudier l’apprentissage automatique dans R.

– Soyez vraiment bon en programmation R et en syntaxe R.

– Etudier en profondeur la théorie et les paramètres sous-jacents pour les algorithmes d’apprentissage machine dans R.

– Évitez ou survoler légèrement toutes les autres tâches nécessaires à la réalisation d’un projet réel.

Je pense que cette approche peut fonctionner pour certaines personnes, mais c’est très long. Beaucoup de sites et de livres, vous apprennent à passer tout votre temps à apprendre à utiliser les algorithmes individuels d’apprentissage automatique.

Ils ne vous apprennent pas non plus le processus de construction de modèles prédictifs d’apprentissage automatique dans R que vous pouvez réellement utiliser pour faire des prédictions. Malheureusement, c’est l’approche utilisée pour enseigner l’apprentissage machine que je vois dans presque tous les livres et cours en ligne sur le sujet.

Vous devez savoir comment compléter les sous-tâches spécifiques d’un projet d’apprentissage machine sur la Plate-forme R. Une fois que vous savez comment effectuer une tâche discrète en utilisant la plate-forme et obtenir un résultat de façon fiable, vous pouvez le faire encore et encore sur vos différents projets. Commençons par un aperçu des tâches courantes dans un projet d’apprentissage automatique.

Le projet peut être divisé en 6 tâches principales :

1. Problème : Enquêter et caractériser le problème afin de mieux comprendre les objectifs du projet.

2. Analyser les données : utiliser des statistiques descriptives et une visualisation pour mieux comprendre les données.

3. Préparer les données : Utiliser les transformations de données afin de mieux exprimer le problème de prédiction à des algorithmes de modélisation.

4. Evaluer les algorithmes : Concevoir un ensemble de test pour évaluer un certain nombre d’algorithmes standard sur les données et sélectionnez les meilleurs.

5. Améliorer les résultats : Utiliser l’algorithme de tuning et les méthodes d’ensemble pour tirer le meilleur parti des algorithmes performants sur vos données.

6. Présenter les résultats : Finaliser le modèle, faire des prévisions et présenter les résultats.

Premier article de blog

Il s’agit de votre tout premier article Cliquez sur le lien Modifier pour le modifier ou le supprimer ou commencez un nouvel article. Si vous le souhaitez, utilisez cet article pour indiquer aux lecteurs pourquoi vous avez commencé ce blog et ce que vous envisagez d’en faire. Si vous avez besoin d’aide, adressez-vous aux gentils utilisateurs de nos forums.