Tracer des graphiques avec R

Nous allons maintenant voir comment explorer de la donnée au travers de plusieurs graphiques, la librairie exploitée sera ggplot2, comprise dans tidyverse. Un cheat sheet se trouve ici pour ggplot2.
Bien entendu il existe également d’autres librairies graphiques telles que plotly (existante également sur Python), permettant de réaliser des graphiques intéractifs, exportables au format HTML, PDF, etc. Nous utiliserons une fois encore un fichier issu d’une compétition kaggle, référençant une liste d’airbnb de la ville Melbourne en Australie.

Objectifs

• Savoir tracer des graphiques avec une, deux ou plusieurs variables
• Se familiariser avec la bibliothèque ggplot2
• Comprendre comment visualiser la répartition d’une variable
• Mettre en avant les liens existant ou non entre plusieurs variables

Récupération du fichier

Le fichier est ici
Allez dans la partie “Data” > “Data Sources” > Sélectionnez “listings_summary_dec18.csv” > en-dessous cliquez sur l’icone download.

Lecture des fichiers

library(tidyverse)

df = read_csv('C:/Users/DIONGA/Downloads/dataset/melbourne airbnb/listings_summary_dec18.csv')

Parsed with column specification:
cols(
  id = col_double(),
  name = col_character(),
  host_id = col_double(),
  host_name = col_character(),
  neighbourhood_group = col_logical(),
  neighbourhood = col_character(),
  latitude = col_double(),
  longitude = col_double(),
  room_type = col_character(),
  price = col_double(),
  minimum_nights = col_double(),
  number_of_reviews = col_double(),
  last_review = col_date(format = ""),
  reviews_per_month = col_double(),
  calculated_host_listings_count = col_double(),
  availability_365 = col_double()
)

df

Analyses Univariées (une seule variable)

Histogramme - variable continue (un grand nombre de valeurs distinctes)

Ici on souhaite afficher un histogramme concernant le prix des airbnb, pour connaitre la distribution de cette variable.
On lui passe donc la variable price, on lui précise de découper le graphique en 100 barres, de se limiter à l’affichage des prix compris entre 0 et 1000, ensuite la fonction seq(0, 1000, 50), détermine l’échelle de l’axe x, on affiche l’axe x de 0 à 1000 par pas de 50.

ggplot(df) +
  aes(price) +
  geom_histogram(bins = 100, fill="lightblue", color="darkblue") +
  scale_x_continuous(breaks = seq(0, 1000, 50), limit=c(0,1000)) +
  ggtitle("Prix des airbnb") +
  xlab("Prix") +
  ylab("Effectifs")

On voit ici que les prix sont principalement situés entre 25€ et 200€, avec une forte densité entre 50 et 150€.

Courbe gaussian

On affiche ici la densité sous forme de courbe, afin de voir si la variable prix pourrait suivre une loi normale.
On passe le paramètre adjust=2, afin de lisser la courbe.

ggplot(df) +
  aes(price) +
  geom_density(kernel = "gaussian", adjust=2, fill="lightblue", color="darkblue", alpha=0.6) +
  scale_x_continuous(breaks = seq(0, 1000, 50), limit=c(0,1000)) +
  ggtitle("Prix des airbnb") +
  xlab("Prix") +
  ylab("Effectifs")

Courbe gaussian centrée réduite

Avec la focntion scale(), on centre la variable, c’est à dire que la moyenne des prix est soustraite à chaque valeur, puis réduite, c’est à dire qu’on divise chaque valeur par l’écart type.

ggplot(df) +
  aes(scale(price)) +
  geom_density(kernel = "gaussian", adjust=2, fill="lightblue", color="darkblue", alpha=0.6) +
  scale_x_continuous(breaks = seq(0, 5, 0.2), limit=c(0,5)) +
  ggtitle("Prix des airbnb") +
  xlab("Prix") +
  ylab("Effectifs")

On observe donc que les prix sont fortement regroupés, avec une longue queue de valeurs extrêmes (prix élevés). On aurait aussi pu utiliser l’échelle logarithmique log2(price), ou la racine carrée de price sqrt(price).

Box plot ou boite à moustaches

La fonction ici permet d’afficher rapidement pour une variable le 1er et 3e quartile, médiane, moyenne, valeurs min et max, permettant d’apprécier d’une autre façon la répartition des valeurs.

summary(df$price)

   Min. 1st Qu.  Median    Mean 3rd Qu.    Max. 
      0      71     111     148     165   12624 

Ici on l’affiche de manière graphique les résultats précédents, dont le principe est le suivant :

Il y a 25% des données entre chaque partie, les points représentes des valeurs extrêmes.

ggplot(df) +
  aes(x = "", y = price) +
  geom_boxplot(na.rm = TRUE, fill="lightblue", color="darkblue", alpha=0.6) +
  coord_flip(ylim=c(0, 2000)) +
  scale_y_continuous(breaks = seq(0, 2000, 100)) +
  ggtitle("Prix des airbnb") +
  xlab("") +
  ylab("Prix")

Diagramme de fréquence - variable discrète (quelques modalités)

ggplot(df) +
  aes(x = room_type) +
  geom_bar(color="red", fill="red", alpha=0.6, width=0.2) +
  coord_flip() +
  ggtitle("Type de logements") +
  xlab("") +
  ylab("Effectifs")

On s’aperçoit très rapidement que les chambres partagés ne représentent pas beaucoup de logements.

ggplot(df) +
  aes(x = neighbourhood) +
  geom_bar(color="red", fill="red", alpha=0.6, width=0.2) +
  coord_flip() +
  ggtitle("Quartiers") +
  xlab("") +
  ylab("Effectifs")

On voit ici que le cartier de Melbourne représente plus de 7000 logements sur 22800, soit près d’un tiers.

Analyses Bivariées (deux variables)

Box plot ou diagramme à moustaches

Il pourrait être intéressant désormais d’afficher la répartition des prix, mais cette fois en fonction des quartier

ggplot(df) +
  aes(x = neighbourhood, y = price) +
  geom_boxplot(na.rm = TRUE, fill="lightblue", color="darkblue", alpha=0.6) +
  coord_flip(ylim=c(0, 2000)) +
  scale_y_continuous(breaks = seq(0, 2000, 200)) +
  ggtitle("Prix des airbnb") +
  xlab("Quartiers") +
  ylab("Prix")

On voit que certains quartiers comme Bayside ou Yarra Ranges possèdent une plus grande diversité de prix que Greater Dandenong par exemple. Egalement ces 2 quartiers ont leur dernier quartile avec des prix plus élevés.

Nuage de points

A partir de là, d’autres idées commencent à émerger, on voudrait savoir qu’est ce qui tire les prix vers le haut, est-ce le type de logement (maison entière, chambre…), l’emplacement, …

ggplot(df) +
  aes(x = room_type, y = price) +
  geom_point(color="red", alpha=0.6) +
  ggtitle("Airbnb") +
  xlab("Type de logement") +
  ylab("Prix")

On voit ici que les prix montent plus haut sur un logement entier, ce qui parait relativement normal.

ggplot(df) +
  aes(x = neighbourhood, y = price) +
  geom_point(color="red", alpha=0.6) +
  theme(axis.text.x = element_text(angle = 90, hjust = 1)) +
  ggtitle("Airbnb") +
  xlab("Quartiers") +
  ylab("Prix")

Là encore on voit que certains quartiers possèdent des valeurs très extrêmes de prix.

ggplot(df) +
  aes(x = minimum_nights, y = price) +
  geom_point(color="red", alpha=0.6) +
  scale_y_continuous(limits = c(0, 2000)) +
  ggtitle("Airbnb") +
  xlab("Nombre de nuits minimum") +
  ylab("Prix")

On peut conclure ici qu’un certain nombre d’hébergeurs demandent un nombre de nuits minimum très élevé, il peut s’agir ici d’erreurs de saisies.
La plupart demandent un nombre de nuits proche de 0, une autre colonne se lève après 300 jours, certainement des hébergeurs louant à l’année.

Analyses multivariées

Matrice de corrélation

On pourrait également se demander si revoir régulièrement son annonce et mettre régulièrement à jour ses textes permet de mieux louer.
Autrement dit le nombre de revues et les disponibilités sont elles corrélées.
Egalement le fait de mettre moins de nuits minimum, augmente t-il le nombre de réservations.

var_comp <- df %>% select(availability_365, number_of_reviews, price, minimum_nights, number_of_reviews, calculated_host_listings_count, availability_365)

matrix_corr <-cor(var_comp)
head(round(matrix_corr,2))

                               availability_365 number_of_reviews price minimum_nights
availability_365                           1.00              0.14  0.11           0.00
number_of_reviews                          0.14              1.00 -0.03          -0.04
price                                      0.11             -0.03  1.00           0.02
minimum_nights                             0.00             -0.04  0.02           1.00
calculated_host_listings_count             0.14              0.06  0.08           0.00
                               calculated_host_listings_count
availability_365                                         0.14
number_of_reviews                                        0.06
price                                                    0.08
minimum_nights                                           0.00
calculated_host_listings_count                           1.00

Afin de mettre en forme cette matrice de corrélation, nous aurons besoin du pckage corrplot :

install.packages("corrplot" ,repos='http://cran.r-project.org')

Error in install.packages : Updating loaded packages

library(corrplot)

col <- colorRampPalette(c("#BB4444", "#EE9988", "#FFFFFF", "#77AADD", "#4477AA"))
corrplot(matrix_corr, method="color", col=col(200), type="upper", tl.cex = 0.8,
         addCoef.col = "black", # Ajout du coefficient de corrélation
         tl.col="black", tl.srt=45, #Rotation des etiquettes de textes
         diag=FALSE # Cacher les coefficients de corrélation sur la diagonale
)

Un coefficent de corrélation évolue entre [-1;1], -1 signifiant une forte corrélation négative, 1 une forte corrélation positive. Ici le coefficent le plus élevé est 0.14, soit une faible corrélation entre le nombre de disponibilités et le nombre de mises à jour de l’annonce, ainsi que le nombre d’annonces pour un propriétaire. Ainsi un propriétaire avec plusieurs annonces et une fréquence de mise à jour plus élevé, à légérement tendance à mieux louer.

Régression linéaire

Un élément intéressant à visualiser, peut être une regression linéaire, afin de visualiser le lien qui existe entre deux variables.
Pour cette dernière analyse, je vous propose d’utiliser le jeu de données suivant sur ce lien.
Ce jeu de données contient des prêts bancaires avec des informations client afin de prévenir les défauts de paiement.

df_bank = read_csv('C:/Users/DIONGA/Downloads/dataset/bank loan/bankloan.csv')

Parsed with column specification:
cols(
  age = col_double(),
  ed = col_double(),
  employ = col_double(),
  address = col_double(),
  income = col_double(),
  debtinc = col_double(),
  creddebt = col_double(),
  othdebt = col_double(),
  default = col_double(),
  preddef1 = col_double(),
  preddef2 = col_double(),
  preddef3 = col_double()
)

df_bank

ggplot(df_bank) +
  aes(x = income, y = employ) +
  geom_smooth(method = "lm") +
  geom_point() +
  xlab("Revenus") +
  ylab("Types d'emplois")

cor(df_bank$income, df_bank$employ) ^ 2

[1] 0.3907407

Ici on voit qu’il y a un lien fort entre le type d’emploi et le revenu, ce qui en soit parait assez évident, pour autant la régression linéaire ici n’explique que 39% de la variance totale.

Synthèse

Fonctions R	Univariées / biavariées / Multivariées	Types de graphiques
Histograme	Univarié	geom_histogram()
Courbe gaussian ou non	Univarié	geom_density()
Boite à moustache	Univarié et bivarié	geom_boxplot()
Diagramme en bâtons	Univarié	geom_bar()
Nuage de points	Bivarié	geom_point()
Quelques plus
Matrice de corrélations	Bivarié et multivarié	corrplot()
Régression linéaire	Bivarié	geom_smooth()