R VS SAS

Clémentine Jager

2020/01/08


Il n’est pas évident de passer d’un langage de programmation à un autre. Les deux langages de programmation SAS et R disposent de certaines différences. Une des différences principales est que SAS fonctionne avec une logique en ligne des tables alors que R fonctionne avec une logique en colonne.

Cependant il y a des outils qui peuvent permettre de s’adapter plus facilement au langage R, tels que le package dplyr développé par RStudio, qui permet d’effectuer les opérations de manipulation de tables de manière très lisible. Nous pouvons donc l’utiliser pour faire nos premiers pas dans l’écosystème R.

Nous espérons que cet article vous permettra de trouver des outils pour débuter sur R sans être perdu, vous trouverez ci-dessous quelques exemples de traductions de programmes SAS en R. Dans un premier temps, les codes seront des exemples de manipulation basique de table à l’aide du package dplyr puis nous verrons des exemples pour trouver des alternatives à des PROC souvent utilisées en SAS.

Les illustrations vont s’appuyer sur la table suivante:

dat <- structure(list(type = c(
  "chat", "chat", "chien", "perroquet",
  "chien", "chat", "chat", "perroquet", "canari", "chien", "perroquet",
  "canari", "chien"
), age = c(
  1, 4, 4, 5, 3, 2, 5, 6, 7, 2, 6,
  7, 8
), couleur = c(
  "blanc", "bleu", "chocolat", "rouge", "bleu",
  "gris", "roux", "multi", "jaune", "jaune", "mutli", "vert", "orange"
), taille = c(20, 17, 35, 10, 40, 19, 18, 9, 4, 43, 13, 6, 15), poids = c(
  4, 3.7, 7, 3.1, 10, 2.5, 2.4, 1.2, 0.6, 11, 1, 0.5,
  6
)), row.names = c(NA, -13L), class = c("tbl_df", "tbl", "data.frame"))

dat

Nous allons également utiliser les packages suivants:

library(dplyr)
library(tidyr)
library(readxl)

Sélection de colonnes

La table est composée de 5 variables (colonnes), type, age, couleur, taille et poids. Une étape DATA de SAS avec l’instruction de table keep permettra de sélectionner les colonnes à garder, dans l’exemple ci-dessous : type, age et couleur.

Le package dplyr pourra réaliser la même opération grâce à la fonction select().

Programme SAS

data dat_select;
  set dat (keep = type age couleur);
run;

Programme R

dat_select <- select(dat, type, age, couleur)

Sélection de lignes

La table est composée de 13 observations. Une étape DATA de SAS avec l’instruction if ou where permettra d’indiquer la condition à respecter pour les observations. Ici, la sélection se porte sur les animaux dont l’age est strictement inférieur à 4.

Dans R, l’utilisation de la fonction filter() est possible pour reproduire le même résultat.

Programme SAS

data dat_filter;
  set dat;
  if age < 4;
run;

Programme R

dat_filter <- filter(dat, age < 4)

Tri d’une table

Pour trier une table, nous utiliserons une PROC SORT dans SAS, avec R, nous pourrons utiliser la fonction arrange().

Programme SAS

proc sort data = dat out = dat_arrange;
  by type;
run;

Programme R

dat_arrange <- arrange(dat, type)

Renommage d’une variable

L’instruction rename de SAS va nous permettre de renommer une variable. L’équivalent en R sera la fonction rename(). Dans notre exemple, nous renommons la variable couleur en color.

Programme SAS

data dat_rename;
   set dat;
   rename couleur = color;
run;

Programme R

dat_rename <- rename(dat, color = couleur)

Création d’une nouvelle variable

L’exemple suivant est plus complet et permet de créer une nouvelle variable: sum_poids qui correspond à la somme des poids par type d’animal.

En SAS, nous utiliserons la table déjà triée précedemment par type. L’instruction by indiquera que le calcul de cette nouvelle variable se fait par groupe d’animal. En R, ce sera la fonction group_by() qui nous permettra de faire la même chose. Avec le programme SAS, la fonction first est aussi utilisée pour indiquer que lorsque c’est la première fois qu’il voit une modalité différente pour la variable type, il réinitialise la varibale sum_poids avec le poids de l’observation et sinon il ajoutera à sum_poids la valeur du poids des observations suivantes.

En R, nous utiliserons la fonction mutate() pour la création d’une variable, pour calculer la somme cumulée, ce sera la fonction cumsum qui sera utilisée.

A la différence de SAS où nous sommes obligé d’ajouter l’instruction retain pour que SAS se souvienne de la modalité de la ligne précédente, R n’impose aucune contrainte.

Note: il n’est pas obligatoire dans R de trier par la variable qui sera utilisée comme variable de groupement.

Programme SAS

data dat_group;
  set dat_arrange;
  retain sum_poids;
  by type;
  if first.type then sum_poids = poids;
  else sum_poids = sum_poids + poids;
run;

Programme R

dat_group <- dat %>%
  arrange(type) %>%
  group_by(type) %>%
  mutate(sum_poids = cumsum(poids))

Pour les deux prochains exemples, nous verrons des fusions de tables horizontales et verticales. Nous aurons ainsi besoin de deux autres tables dat_merge et dat_plus que vous trouverez ci-dessous.

dat_merge <- structure(list(type = c("chat", "chien", "canari", "perroquet"), espece = c("mammifère", "mammifère", "oiseau", "oiseau")), row.names = c(
  NA,
  -4L
), class = c("tbl_df", "tbl", "data.frame"))
dat_merge
dat_plus <- structure(list(type = c(
  "chien", "perroquet", "chien", "chat",
  "chat"
), age = c(6, 7, 2, 6, 7), couleur = c(
  "bleu", "mutli",
  "jaune", "roux", "vert"
), taille = c(15, 13, 43, 6, 15), poids = c(
  5,
  1, 11, 0.5, 6
)), row.names = c(NA, -5L), class = c(
  "tbl_df",
  "tbl", "data.frame"
))
dat_plus

Combinaison verticale de tables

Pour combiner deux tables verticalement, une étape DATA avec l’instruction set sera utilisée. En R, c’est la fonction bind_rows qui sera utilisée.

Programme SAS

data dat_set ;
   set dat dat_plus;
run;

Programme R

dat_set <- dat %>%
  bind_rows(dat_plus)

Combinaison horizontale de tables

Pour combiner deux tables horizontalement en fonction d’une clé de jointure, une étape DATA avec l’instruction merge sera utilisée et l’instruction by pour indiquer la variable qui servira de clé de jointure. En R, c’est la fonction full_join qui sera utilisée avec comme paramètre by qui permettra d’indiquer la variable qui sera la clé de jointure.

Note: avec une étape DATA pour fusionner deux tables, elles devront être triées par la variable utilisée comme clé de jointure, ce qui n’est pas nécessaire avec les fonctions de jointures disponibles dans le package dplyr.

Programme SAS

proc sort data = dat out = dat_sort; by type; run;
proc sort data = dat_merge out = dat_merge_sort; by type; run;

data dat_merge_res;
  merge dat_sort(in = a) dat_merge_sort(in = b) ;
  if a;
  by type;
run;

Programme R

dat_merge_res <- dat %>%
  left_join(dat_merge, by = "type")

Quelques fonctions équivalentes à certaines PROC

PROC IMPORT

La PROC IMPORT de SAS va permettre d’importer des fichiers excel .xlsx, l’équivalent en R proviendra du package readxl avec la fonction read_excel().

Programme SAS

proc import datafile="pres_drees.xlsx" out = dat dbms = xlsx;
getname=yes;
run;

Programme R

library(readxl)

dat <- read_excel("pres_drees.xlsx", sheet = "Feuil1")

PROC MEANS

La PROC MEANS de SAS va permettre de faire un résumé (moyenne, min, max …) sur les variables quantitatives qui se trouvent dans la table. Un équivalent en R serait la fonction summary() qui fera un résumé également sur les variables qualitatives présentes dans la table.

Programme SAS

proc means data = dat;
run;

Programme R

summary_dat <- summary(dat)
##      type                age          couleur              taille     
##  Length:13          Min.   :1.000   Length:13          Min.   : 4.00  
##  Class :character   1st Qu.:3.000   Class :character   1st Qu.:10.00  
##  Mode  :character   Median :5.000   Mode  :character   Median :17.00  
##                     Mean   :4.615                      Mean   :19.15  
##                     3rd Qu.:6.000                      3rd Qu.:20.00  
##                     Max.   :8.000                      Max.   :43.00  
##      poids       
##  Min.   : 0.500  
##  1st Qu.: 1.200  
##  Median : 3.100  
##  Mean   : 4.077  
##  3rd Qu.: 6.000  
##  Max.   :11.000

PROC TRANSPOSE

La PROC TRANSPOSE va permettre de pivoter une table. En R, pour avoir l’équivalent du résultat SAS, il faut une pré-modification de la table pour ensuite pouvoir utiliser la fonction pivot_wider() du package tidyr.

Programme SAS

proc sort data = dat; by type; run;

proc transpose data = dt out = dat_transpose;
   var age;
   by type;
run;

Programme R

dat_t <- dat %>%
  select(type, age) %>%
  group_by(type) %>%
  mutate(col = seq_len(n()))

dat_transpose <- pivot_wider(
  data = dat_t,
  names_from = col, values_from = age,
  names_prefix = "col"
)

PROC FREQ

La PROC FREQ de SAS va permettre de créer un tableau de fréquence. Dans l’exemple suivant, ce sont les variable age et type qui sont utilisées. En R, un équivalent peut être la fonction table().

Programme SAS

proc freq data = dat;
   tables age * type;
run;

Programme R

table_dat <- table(dat$age, dat$type)
##    
##     canari chat chien perroquet
##   1      0    1     0         0
##   2      0    1     1         0
##   3      0    0     1         0
##   4      0    1     1         0
##   5      0    1     0         1
##   6      0    0     0         2
##   7      2    0     0         0
##   8      0    0     1         0

Il est aussi possible d’avoir un rendu plus proche de celui de la PROC FREQ de SAS en utilisant la fonction proc_freq du package flextable.

library(flextable)

proc_freq(dat, "age", "type")

PROC CORR

La PROC CORR de SAS permet de calculer les corrélations entre les variables précisées dans l’instruction var. Le type de corrélation effectué est choisi avec l’indication pearson dans notre cas. En R, ce sera la fonction cor() qui sera utilisée en précisant pour argument de method : "pearson".

Programme SAS

proc corr data = dat pearson;
   var age poids taille;
run;

Programme R

cor_dat <- cor(dat[, c("age", "poids", "taille")],
  method = "pearson"
)
##               age      poids     taille
## age     1.0000000 -0.4894355 -0.6526009
## poids  -0.4894355  1.0000000  0.9280667
## taille -0.6526009  0.9280667  1.0000000

PROC REG

Pour effectuer une régression linéaire, la PROC REG sera utilisée, en R ce sera la fonction lm(). Pour obtenir les résultats de cette regression, nous utiliserons la fonction summary().

Programme SAS

proc reg data = dat ;
   model poids = age;
run;

Programme R

model <- lm(poids ~ age, dat)
summary(model)
## 
## Call:
## lm(formula = poids ~ age, data = dat)
## 
## Residuals:
##    Min     1Q Median     3Q    Max 
## -3.612 -1.800 -1.378  2.444  4.888 
## 
## Coefficients:
##             Estimate Std. Error t value Pr(>|t|)   
## (Intercept)   7.6685     2.1189   3.619  0.00403 **
## age          -0.7782     0.4180  -1.861  0.08959 . 
## ---
## Signif. codes:  0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1
## 
## Residual standard error: 3.158 on 11 degrees of freedom
## Multiple R-squared:  0.2395, Adjusted R-squared:  0.1704 
## F-statistic: 3.465 on 1 and 11 DF,  p-value: 0.08959

Cet article visait uniquement à vous donner un aperçu des rapprochements possibles entre R et SAS sur des opérations basiques, lorsque l’on connait SAS et que l’on souhaite passer sous R. En espérant que cet article vous a aidé. :)