+
+
+
+
+
+
+
+
+
+
+Autour du SARS-CoV-2 (Covid-19)
+Elia Pérennès
+ +
+
+
+
+
+
+
+Le but est ici de reproduire des graphes semblables à ceux du South China Morning Post (SCMP), sur la page The Coronavirus Pandemic et qui montrent pour différents pays le nombre cumulé (c’est-à-dire le nombre total de cas depuis le début de l’épidémie) de personnes atteintes de la maladie à coronavirus 2019. Les données que nous utiliserons sont compilées par le Johns Hopkins University Center for Systems Science and Engineering (JHU CSSE).
+Tout d’abord, on nettoie l’espace de travail sur R et on charge les librairies nécessaires à l’exécution de notre code :
+ + + + + + + +
+
+Etude du nombre de cas
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Préparation des données
+Nous téléchargeons les données recensant le nombre de cas de Covid-19 disponibles sur le Github du JHU CSSE.
+ + + +data_url = "https://raw.githubusercontent.com/CSSEGISandData/COVID-19/master/csse_covid_19_data/csse_covid_19_time_series/time_series_covid19_confirmed_global.csv"
+data = read.csv(data_url, stringsAsFactors=FALSE)Regardons nos données :
+ + + + + + +
+
+
+
+
+
+On retraite dans un premier temps les noms des colonnes de dates en enlevant le X devant chaque nom de colonne :
+ + + + + + + [1] "Province.State" "Country.Region" "Lat" "Long" "1.22.20"
+ [6] "1.23.20" "1.24.20" "1.25.20" "1.26.20" "1.27.20" On sépare les données sur Hong-Kong de celles du reste de la Chine :
+ + + + + + + +On filtre la base de données pour ne garder que les pays suivants : la Belgique (Belgium), la Chine - toutes les provinces sauf Hong-Kong (China), Hong Kong (China, Hong-Kong), la France métropolitaine (France), l’Allemagne (Germany), l’Iran (Iran), l’Italie (Italy), le Japon (Japan), la Corée du Sud (Korea, South), la Hollande sans les colonies (Netherlands), le Portugal (Portugal), l’Espagne (Spain), le Royaume-Unis sans les colonies (United Kingdom) ainsi que les États-Unis (US).
+ + + +data = data %>% filter(Country.Region %in% c("Belgium","China",
+ "Hong Kong","France","Germany","Iran","Italy",
+ "Japan","Korea, South","Netherlands","Portugal","Spain",
+ "United Kingdom", "US") )
+ On enlève les DOM-TOM, ainsi que les colonies du Royaume-Uni et des Pays-Bas :
+ + + +data = data %>% filter(Country.Region == "China" | Country.Region == "Hong Kong" | (Country.Region != "China" & Province.State == ""))On supprime les colonnes inutiles pour la suite de l’analyse :
+ + + + + + + +On regarde s’il y a des valeurs manquantes dans chaque colonne :
+ + + + + + +[1] 0Aucune valeur manquante à signaler.
+On regroupe les différentes provinces de Chine au sein d’une seule observation :
+ + + + + + + +On transpose la base de données pour avoir les dates en lignes et les noms de pays en colonnes, puis on retraite les noms des lignes pour qu’ils soient au format date :
+ + + +data = as.data.frame(data) # pour éviter que le df soit au format tibble
+rownames(data) = data$Country.Region
+data$Country.Region = NULL
+tdata = as.data.frame(t(data))
+tdata$Date = as.Date(rownames(tdata), format = "%m.%d.%y")On visualise le rendu final de nos données :
+ + + +rownames(tdata) = c()
+tdata = tdata %>%
+ select(Date, everything()) # On met la colonne de Date en première position
+tdata
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Visualisation des données
+Avant de réaliser nos graphiques, on change le format de la base de données pour le passer de “Wide” à “Long”:
+ + + + + + +
+
+
+
+
+
+Puis on trace un graphique animé représentant la série temporelle du nombre cumulé de cas de Covid-19 pour les différents pays de notre base de données :
+ + + +library(ggplot2)
+library(gganimate)
+ylab = c(0,1,2,3,4,5,6)
+p = ggplot(meltdf,aes(x=Date,y=value,colour=variable,group=variable)) + geom_line(size = 1) + scale_x_date(date_breaks = "1 month", date_labels = "%b-%y") + labs(y="Nombre de cas en cumulé", x = "Mois") + scale_y_continuous(labels = paste0(ylab, "M"), breaks = 10^6 * ylab) +
+ labs(color='Pays') + transition_reveal(Date) + ggtitle("Evolution du nombre de cas de Covid-19 par pays")
+animate(p, duration = 8, fps = 20, width = 800, height = 500, renderer = gifski_renderer())
+anim_save('output.gif')Afin de pouvoir visualiser plus clairement les évolutions des différents pays, on réalise maintenant le même graphique mais avec une échelle transformée via la fonction Sinus hyperbolique inverse (la transformation logarithmique n’étant pas appropriée à cause des valeurs nulles) :
+ + + +asinh_trans = scales::trans_new(
+ "inverse_hyperbolic_sine",
+ transform = function(x) {asinh(x)},
+ inverse = function(x) {sinh(x)}
+ )
+p = ggplot(meltdf,aes(x=Date,y=value,colour=variable,group=variable)) +
+ geom_line(size = 1) + scale_x_date(date_breaks = "1 month", date_labels = "%b-%y") + labs(y="Nombre de cas en cumulé (échelle transformée)", x = "Mois") +
+ scale_y_continuous(trans = asinh_trans) + labs(color='Pays') +
+ ggtitle("Evolution du nombre de cas de Covid-19 par pays") + theme(axis.text=element_text(size=6.5),
+ axis.title=element_text(size=8),
+ plot.title = element_text(size=10),
+ legend.title = element_text(size = 8),
+ legend.text = element_text(size = 6.5))
+
+
+Etude du nombre de décès
+Nous réalisons maintenant la même étude que précédemment sur le nombre de décès dus à la Covid-19. Les données sont toujours téléchargées sur le Github du JHU CSSE.
+
+
+
+
+
+
+
+
+
+
+Préparation des données
+ + + +data_url = "https://raw.githubusercontent.com/CSSEGISandData/COVID-19/master/csse_covid_19_data/csse_covid_19_time_series/time_series_covid19_deaths_global.csv"
+data = read.csv(data_url, stringsAsFactors=FALSE)Regardons nos données :
+ + + + + + + +Nous effectuons les mêmes retraitements que précédemment :
+ + + +names(data)[5:ncol(data)] = substring(names(data)[5:ncol(data)],2)
+data[data$Province.State == "Hong Kong","Country.Region"] = "Hong Kong"
+data = data %>% filter(Country.Region %in% c("Belgium","China",
+ "Hong Kong","France","Germany","Iran","Italy",
+ "Japan","Korea, South","Netherlands","Portugal","Spain",
+ "United Kingdom", "US") )
+data = data %>% filter(Country.Region == "China" | Country.Region == "Hong Kong" | (Country.Region != "China" & Province.State == ""))
+data = data %>% select(-c('Province.State', 'Lat', 'Long'))
+data = data %>% group_by(Country.Region) %>% summarise_all(sum)
+data = as.data.frame(data) # pour éviter que le df soit au format tibble
+rownames(data) = data$Country.Region
+data$Country.Region = NULL
+tdata = as.data.frame(t(data))
+tdata$Date = as.Date(rownames(tdata), format = "%m.%d.%y")On visualise le rendu final de nos données :
+ + + + + + + +
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Visualisation des données
+On change le format de la base de données pour le passer de “Wide” à “Long”:
+ + + + + + + +Puis on trace un graphique animé représentant la série temporelle du nombre cumulé de décès dus à la Covid-19 pour les différents pays de notre base de données :
+ + + + +
+Afin de pouvoir visualiser plus clairement les évolutions des différents pays, on réalise maintenant le même graphique mais avec une échelle transformée via la fonction Sinus hyperbolique inverse (la transformation logarithmique n’étant pas appropriée à cause des valeurs nulles) :
+ + + +p = ggplot(meltdf,aes(x=Date,y=value,colour=variable,group=variable)) +
+ geom_line(size = 1) + scale_x_date(date_breaks = "1 month", date_labels = "%b-%y") + labs(y="Nombre de décès en cumulé (échelle transformée)", x = "Mois") +
+ scale_y_continuous(trans = asinh_trans) + labs(color='Pays') +
+ ggtitle("Evolution du nombre de décès dus à la Covid-19 par pays") + theme(axis.text=element_text(size=6.5),
+ axis.title=element_text(size=8),
+ plot.title = element_text(size=10),
+ legend.title = element_text(size = 8),
+ legend.text = element_text(size = 6.5))
---
title: "Autour du SARS-CoV-2 (Covid-19)"
author: "Elia Pérennès"
output:
  html_notebook :
    toc: true
    toc_depth: 2
    number_sections: false
    theme: journal
    highlight: tango
documentclass: article
classoption: a4paper
header-includes:
- \usepackage[french]{babel}
- \usepackage[upright]{fourier}
- \hypersetup{colorlinks=true,pagebackref=true}
---

```{r setup, include=FALSE}
knitr::opts_chunk$set(echo = TRUE, fig.align="center") 
```

Le but est ici de reproduire des graphes semblables à ceux du [South China Morning Post (SCMP)](https://www.scmp.com/), sur la page [The Coronavirus Pandemic](https://www.scmp.com/coronavirus?src=homepage_covid_widget) et qui montrent pour différents pays le nombre cumulé (c'est-à-dire le nombre total de cas depuis le début de l'épidémie) de personnes atteintes de la maladie à coronavirus 2019. Les données que nous utiliserons sont compilées par le [*Johns Hopkins University Center for Systems Science and Engineering (JHU CSSE)*](https://systems.jhu.edu/).

Tout d'abord, on nettoie l'espace de travail sur R et on charge les librairies nécessaires à l'exécution de notre code :
```{r}
rm(list = ls())
library(dplyr)
library(ggplot2)
library(gganimate)
library(reshape2)
```


# Etude du nombre de cas 

## Préparation des données

Nous téléchargeons les données recensant le nombre de cas de Covid-19 disponibles sur le [Github du JHU CSSE](https://github.com/CSSEGISandData/COVID-19).
```{r}
data_url = "https://raw.githubusercontent.com/CSSEGISandData/COVID-19/master/csse_covid_19_data/csse_covid_19_time_series/time_series_covid19_confirmed_global.csv"
data = read.csv(data_url, stringsAsFactors=FALSE)
```


Regardons nos données :
```{r}
data
```

On retraite dans un premier temps les noms des colonnes de dates en enlevant le *X* devant chaque nom de colonne :
```{r}
names(data)[5:ncol(data)] = substring(names(data)[5:ncol(data)],2)
names(data)[1:10]
```

On sépare les données sur Hong-Kong de celles du reste de la Chine :

```{r}
data[data$Province.State == "Hong Kong","Country.Region"] = "Hong Kong"
```


On filtre la base de données pour ne garder que les pays suivants : la Belgique (Belgium), la Chine - toutes les provinces sauf Hong-Kong (China), Hong Kong (China, Hong-Kong), la France métropolitaine (France), l’Allemagne (Germany), l’Iran (Iran), l’Italie (Italy), le Japon (Japan), la Corée du Sud (Korea, South), la Hollande sans les colonies (Netherlands), le Portugal (Portugal), l’Espagne (Spain), le Royaume-Unis sans les colonies (United Kingdom) ainsi que les États-Unis (US).

```{r}
data = data %>% filter(Country.Region %in% c("Belgium","China",
                                       "Hong Kong","France","Germany","Iran","Italy",
                                       "Japan","Korea, South","Netherlands","Portugal","Spain",
                                       "United Kingdom", "US") )
  
```

On enlève les DOM-TOM, ainsi que les colonies du Royaume-Uni et des Pays-Bas : 
```{r}
data = data %>% filter(Country.Region == "China" | Country.Region == "Hong Kong" | (Country.Region != "China" & Province.State == ""))
```

On supprime les colonnes inutiles pour la suite de l'analyse :
```{r}
data = data %>% select(-c('Province.State', 'Lat', 'Long'))
```

On regarde s'il y a des valeurs manquantes dans chaque colonne :
```{r}
sum(colSums(is.na(data)))
```
Aucune valeur manquante à signaler.

On regroupe les différentes provinces de Chine au sein d'une seule observation :
```{r}
data = data %>% group_by(Country.Region) %>% summarise_all(sum)
```

On transpose la base de données pour avoir les dates en lignes et les noms de pays en colonnes, puis on retraite les noms des lignes pour qu'ils soient au format date :
```{r}
data = as.data.frame(data) # pour éviter que le df soit au format tibble
rownames(data) = data$Country.Region
data$Country.Region = NULL
tdata = as.data.frame(t(data))
tdata$Date = as.Date(rownames(tdata), format = "%m.%d.%y")
```

On visualise le **rendu final de nos données** :
```{r}
rownames(tdata) = c()
tdata = tdata %>%
  select(Date, everything()) # On met la colonne de Date en première position
tdata
```


## Visualisation des données

Avant de réaliser nos graphiques, on change le format de la base de données pour le passer de "Wide" à "Long":
```{r}
meltdf = melt(tdata, id = "Date")
meltdf
```

Puis on trace un graphique animé représentant la série temporelle du nombre cumulé de cas de Covid-19 pour les différents pays de notre base de données :
```{r, results = "hide"}
ylab = c(0,1,2,3,4,5,6)
p = ggplot(meltdf,aes(x=Date,y=value,colour=variable,group=variable)) + geom_line(size = 1) + scale_x_date(date_breaks = "1 month", date_labels = "%b-%y") + labs(y="Nombre de cas en cumulé", x = "Mois") + scale_y_continuous(labels = paste0(ylab, "M"), breaks = 10^6 * ylab) +
  labs(color='Pays') + transition_reveal(Date) + ggtitle("Evolution du nombre de cas de Covid-19 par pays")
animate(p, duration = 8, fps = 20, width = 800, height = 500, renderer = gifski_renderer())
anim_save('output.gif')
```

<center>
![](output.gif){height="500" width="800"}
</center>


Afin de pouvoir visualiser plus clairement les évolutions des différents pays, on réalise maintenant le même graphique mais avec une échelle transformée via la fonction Sinus hyperbolique inverse (la transformation logarithmique n'étant pas appropriée à cause des valeurs nulles)  :

```{r, fig.align='center'}
asinh_trans = scales::trans_new(
  "inverse_hyperbolic_sine",
  transform = function(x) {asinh(x)},
  inverse = function(x) {sinh(x)}
  )
p = ggplot(meltdf,aes(x=Date,y=value,colour=variable,group=variable)) + 
  geom_line(size = 1) + scale_x_date(date_breaks = "1 month", date_labels = "%b-%y") + labs(y="Nombre de cas en cumulé (échelle transformée)", x = "Mois") + 
  scale_y_continuous(trans = asinh_trans) + labs(color='Pays') + 
  ggtitle("Evolution du nombre de cas de Covid-19 par pays") + theme(axis.text=element_text(size=6.5),
        axis.title=element_text(size=8),
        plot.title = element_text(size=10),
        legend.title = element_text(size = 8),
        legend.text = element_text(size = 6.5))
```

<center>
```{r fig.width=8.5, fig.height=5, echo = FALSE}
p
```
</center>

# Etude du nombre de décès

Nous réalisons maintenant la même étude que précédemment sur le nombre de décès dus à la Covid-19. Les données sont toujours téléchargées sur le [Github du JHU CSSE](https://github.com/CSSEGISandData/COVID-19).

## Préparation des données

```{r}
data_url = "https://raw.githubusercontent.com/CSSEGISandData/COVID-19/master/csse_covid_19_data/csse_covid_19_time_series/time_series_covid19_deaths_global.csv"
data = read.csv(data_url, stringsAsFactors=FALSE)
```


Regardons nos données :
```{r}
data
```

Nous effectuons les mêmes retraitements que précédemment :
```{r}
names(data)[5:ncol(data)] = substring(names(data)[5:ncol(data)],2)
data[data$Province.State == "Hong Kong","Country.Region"] = "Hong Kong"
data = data %>% filter(Country.Region %in% c("Belgium","China",
                                       "Hong Kong","France","Germany","Iran","Italy",
                                       "Japan","Korea, South","Netherlands","Portugal","Spain",
                                       "United Kingdom", "US") )
data = data %>% filter(Country.Region == "China" | Country.Region == "Hong Kong" | (Country.Region != "China" & Province.State == ""))
data = data %>% select(-c('Province.State', 'Lat', 'Long'))
data = data %>% group_by(Country.Region) %>% summarise_all(sum)
data = as.data.frame(data) # pour éviter que le df soit au format tibble
rownames(data) = data$Country.Region
data$Country.Region = NULL
tdata = as.data.frame(t(data))
tdata$Date = as.Date(rownames(tdata), format = "%m.%d.%y")
```

On visualise le **rendu final de nos données** :
```{r}
rownames(tdata) <- c()
tdata = tdata %>%
  select(Date, everything()) # On met la colonne de Date en première position
tdata
```


## Visualisation des données

On change le format de la base de données pour le passer de "Wide" à "Long":
```{r}
meltdf = melt(tdata, id = "Date")
meltdf
```

Puis on trace un graphique animé représentant la série temporelle du nombre cumulé de décès dus à la Covid-19 pour les différents pays de notre base de données :
```{r, results = "hide"}
p = ggplot(meltdf,aes(x=Date,y=value,colour=variable,group=variable)) + geom_line(size = 1) + scale_x_date(date_breaks = "1 month", date_labels = "%b-%y") + labs(y="Nombre de décès en cumulé", x = "Mois") + labs(color='Pays') + transition_reveal(Date) + ggtitle("Evolution du nombre de décès dus à la Covid-19 par pays")
animate(p, duration = 8, fps = 20, width = 800, height = 500, renderer = gifski_renderer())
anim_save('outputdeaths.gif')
```

<center>
![](outputdeaths.gif){height="500" width="800"}
</center>


Afin de pouvoir visualiser plus clairement les évolutions des différents pays, on réalise maintenant le même graphique mais avec une échelle transformée via la fonction Sinus hyperbolique inverse (la transformation logarithmique n'étant pas appropriée à cause des valeurs nulles)  :

```{r}
p = ggplot(meltdf,aes(x=Date,y=value,colour=variable,group=variable)) + 
  geom_line(size = 1) + scale_x_date(date_breaks = "1 month", date_labels = "%b-%y") + labs(y="Nombre de décès en cumulé (échelle transformée)", x = "Mois") +  
  scale_y_continuous(trans = asinh_trans) + labs(color='Pays') + 
  ggtitle("Evolution du nombre de décès dus à la Covid-19 par pays")  + theme(axis.text=element_text(size=6.5),
        axis.title=element_text(size=8),
        plot.title = element_text(size=10),
        legend.title = element_text(size = 8),
        legend.text = element_text(size = 6.5))
```

<center>
```{r fig.width=8.5, fig.height=5, echo = FALSE}
p
```
</center>



+
+
+
+