Ce document a été généré avec l’outil R Markdown. Le code R et les données qui ont été utilisées sont ainsi mis à disposition et permettent donc la reproductibilité des résultats obtenus.

Par ailleurs, le document est mis à jour automatiquement chaque jour. Pour consulter les archives, cliquer ici.

Source de données utilisées:

Questions de recherche:

En fonction des réponses aux questions précédentes :

Packages et fonctions locales à charger:

library(cartogram)
library(cartography)
library(forecast)
library(kableExtra)
library(rgdal)
library(tidyverse)
library(vistime)
library(zoo)
source("fonctions.R")

Version de R utilisée:

R.version
##                _                           
## platform       x86_64-pc-linux-gnu         
## arch           x86_64                      
## os             linux-gnu                   
## system         x86_64, linux-gnu           
## status                                     
## major          4                           
## minor          0.3                         
## year           2020                        
## month          10                          
## day            10                          
## svn rev        79318                       
## language       R                           
## version.string R version 4.0.3 (2020-10-10)
## nickname       Bunny-Wunnies Freak Out

1 Données hospitalières relatives à l’épidémie de COVID-19

1.1 Présentation des données

1.1.1 Données par département

Dans un premier temps, on met à jour les données tous les jours de façon automatique.

Comment se présente les données du Ministère de la Santé ?

dep jour incid_hosp incid_rea incid_dc incid_rad nom_dep region
17987 69 2020-11-27 100 8 15 105 Rhône Auvergne-Rhône-Alpes
17988 69 2020-11-28 49 9 11 57 Rhône Auvergne-Rhône-Alpes
17989 69 2020-11-29 40 9 9 9 Rhône Auvergne-Rhône-Alpes
17990 69 2020-11-30 43 6 15 34 Rhône Auvergne-Rhône-Alpes

Ici il s’agit des données qui donnent chaque jour par département :

  • le nombre de nouvelles entrées en hospitalisations
  • le nombre de nouvelles entrées en réanimations
  • le nombre de décés
  • le nombre de sorties

On créé des fenêtres de 7 jour à partir du dernier jour observé. Par exemple si nous avons les données d’hospitalisation jusqu’au 30 novembre 2020 la semaine qui correspond à la semaine t0 correspond à la fenêtre [24 novembre 2020; 30 novembre 2020]. Dans chaque fenêtre, on calcule le nombre de nouvelles hospitalisations, réanimations et décès par département.

1.1.2 Données par région

On dispose égaglement des données d’hospitalisations/réanimations/décès par classe d’âge à la différence qu’il s’agit de données régionales et qu’il s’agit des données de stock (nombre d’hospitalisations et réanimations en cours) et pas du nombre de nouvelles hospitalisations. On peut toutefois estimer le nombre de nouvelles hospitalisations ou décès en faisant les différences des valeurs d’un jour sur l’autre.

my_url <- "https://www.data.gouv.fr/fr/datasets/r/08c18e08-6780-452d-9b8c-ae244ad529b3"
if (!file.exists(paste0(getwd(), "/data/age", to_day, ".csv"))) {
  download.file(my_url, destfile = paste0(getwd(), "/data/age", to_day, ".csv"))
}
hospital_age <- read.csv(paste0(getwd(), "/data/age", to_day, ".csv"), sep = ";")
# On ajoute le nom des régions:
hospital_age <- merge(hospital_age, code_region, by.x = "reg", by.y = "code")
# On utilise le format date pour coder le jour:
hospital_age$jour <- as.Date(hospital_age$jour)
# on affecte la semaine
hospital_age$semaine <- num_semaine(hospital_age$jour)

# on calcule les nouvelles hospitalisations/réanimations/décès
hospital_age$new_hosp <- 0
hospital_age$new_rea <- 0
hospital_age$new_dc <- 0

for (k in nrow(hospital_age):1) {
  age_k <- hospital_age$cl_age90[k] 
  jour_k <- hospital_age$jour[k] 
  reg_k <- hospital_age$reg[k] 
  rad_k <- hospital_age$rad[k] 
  dc_k <- hospital_age$dc[k] 
  
  ind_k <- which(hospital_age$reg == reg_k & hospital_age$cl_age90 == age_k & hospital_age$jour == jour_k - 1)
  if (length(ind_k) == 1) {
    hospital_age$new_hosp[k] <- max((hospital_age$hosp[k] - hospital_age$hosp[ind_k]) + 
                                (hospital_age$dc[k] - hospital_age$dc[ind_k]) +     
                              (hospital_age$rad[k] - hospital_age$rad[ind_k]) +
                              (hospital_age$rea[k] - hospital_age$rea[ind_k]), 0)
    hospital_age$new_rea[k] <- max((hospital_age$dc[k] - hospital_age$dc[ind_k]) +     
                              (hospital_age$rea[k] - hospital_age$rea[ind_k]), 0) 
    hospital_age$new_dc[k] <- max((hospital_age$dc[k] - hospital_age$dc[ind_k]), 0) 
  }
}
# on aggrege par semaine
my_basis_age <- hospital_age %>%
  group_by(region, semaine, cl_age90) %>%
  dplyr::summarize(hosp = sum(new_hosp),
                   rea = sum(new_rea),
                   dc = sum(new_dc),
            jour = max(jour),
            region = unique(region))
# On met au format wide
my_basis_age_wide <- tidyr::pivot_wider(my_basis_age,
                           id_cols = c("semaine", "region", "jour", "hosp", "rea", "dc", "cl_age90"),
                           names_from = "cl_age90",
                           values_from = c("hosp", "rea", "dc"))

1.2 Quelle est la situation cette semaine ?

On va calculer quelques chiffres clés pour mesure la situation des régions sur les 7 derniers jours qui viennent de s’écouler : [24 novembre 2020; 30 novembre 2020].

1.2.1 Résumé des hospitalisations

On représente par région:

  • le nombre total de nouvelles hospitalisations (semaine [24 novembre 2020; 30 novembre 2020]).

  • le nombre moyen journalier de nouvelles hospitalisations (semaine [24 novembre 2020; 30 novembre 2020]).

  • l’évolution (en pourcentage) entre la semaine [17 novembre 2020; 23 novembre 2020] et la semaine [24 novembre 2020; 30 novembre 2020].

region total semaine moyenne jour evolution en %
Auvergne-Rhône-Alpes 1836 262 -30
Ile-de-France 1580 226 -31.7
Grand Est 1005 144 -21.3
Provence-Alpes-Côte d’Azur 985 141 -23.9
Hauts-de-France 924 132 -30.2
Bourgogne-Franche-Comté 661 94 -25.3
Nouvelle-Aquitaine 572 82 -19.7
Occitanie 506 72 -37.1
Pays de la Loire 355 51 -29.6
Normandie 346 49 -27.5
Centre-Val de Loire 300 43 -26.8
Bretagne 140 20 -32
DOM-TOM 62 9 -28.7
Corse 7 1 -68.2
France entière 9279 1326 -28.3

On représente par département la carte des nouvelles hospitalisations sur la dernière semaine observée ([24 novembre 2020; 30 novembre 2020])

## OGR data source with driver: ESRI Shapefile 
## Source: "/media/thibault/My Passport/confinement/covid/departements 2015/DEPARTEMENT", layer: "DEPARTEMENT"
## with 96 features
## It has 11 fields

1.2.2 Résumé des réanimations

On représente par région:

  • le nombre total de nouvelles réanimations (semaine [24 novembre 2020; 30 novembre 2020]).

  • le nombre moyen journalier de nouvelles réanimations (semaine [24 novembre 2020; 30 novembre 2020]).

  • l’évolution (en pourcentage) entre la semaine [17 novembre 2020; 23 novembre 2020] et la semaine [24 novembre 2020; 30 novembre 2020].

region total semaine moyenne jour evolution en %
Auvergne-Rhône-Alpes 277 40 -24.7
Ile-de-France 257 37 -35.9
Hauts-de-France 151 22 -33.2
Provence-Alpes-Côte d’Azur 128 18 -22.4
Grand Est 118 17 -33
Bourgogne-Franche-Comté 96 14 -30.9
Occitanie 94 13 -38.2
Nouvelle-Aquitaine 60 9 -36.2
Centre-Val de Loire 54 8 -6.9
Pays de la Loire 38 5 -34.5
Normandie 35 5 -47
Bretagne 18 3 -14.3
DOM-TOM 15 2 -42.3
Corse 5 1 66.7
France entière 1346 192 -31.1

On représente par département la carte des nouvelles réanimations sur la dernière semaine observée ([24 novembre 2020; 30 novembre 2020])

1.2.3 Résumé des décès

On représente par région:

  • le nombre total de nouveaux décès (semaine [24 novembre 2020; 30 novembre 2020]).

  • le nombre moyen journalier de nouveaux décès (semaine [24 novembre 2020; 30 novembre 2020]).

  • l’évolution (en pourcentage) entre la semaine [17 novembre 2020; 23 novembre 2020] et la semaine [24 novembre 2020; 30 novembre 2020].

region total semaine moyenne jour evolution en %
Auvergne-Rhône-Alpes 536 77 -13.5
Ile-de-France 360 51 -12.8
Grand Est 254 36 4.1
Hauts-de-France 219 31 -9.9
Provence-Alpes-Côte d’Azur 210 30 -25.8
Bourgogne-Franche-Comté 177 25 -3.3
Occitanie 148 21 -16.9
Nouvelle-Aquitaine 146 21 -3.3
Normandie 118 17 15.7
Pays de la Loire 89 13 2.3
Centre-Val de Loire 84 12 -15.2
Bretagne 48 7 -5.9
DOM-TOM 6 1 -68.4
Corse 1 0 -80
France entière 2396 342 -10.5

On représente par département la carte des nouveaux décès sur la dernière semaine observée ([24 novembre 2020; 30 novembre 2020])

1.3 Comment a évolué la situation depuis le début de l’épidémie ?

1.3.1 Graphique d’évolution

1.3.1.1 Hospitalisations

Ici, on représente le nombre d’entrée en hospitalisations par semaine en fonction du temps sur la France entière.

On représente la même figure mais en mettant en relief la répartition des valeurs par région :

On représente la même figure mais en mettant en relief la répartition des valeurs par classe d’âge :

On met les valeurs en pourcentages pour que le graphique soit plus visible

1.3.1.2 Réanimations

On représente le nombre cummulé d’entrée en réanimations par semaine en fonction du temps sur la France entière.

On représente la même figure mais en mettant en relief la répartition des valeurs par région :

On représente la même figure mais en mettant en relief la répartition des valeurs par classe d’âge :

On met les valeurs en pourcentages pour que le graphique soit plus visibles

Enfin, on représente le ratio réanimations / hospitalisations :

1.3.1.3 Décès

On représente le nombre cummulé de nouveaux décès par semaine en fonction du temps sur la France entière.

On représente la même figure mais en mettant en relief la répartition des valeurs par région :

On représente la même figure mais en mettant en relief la répartition des valeurs par classe d’âge :

On met les valeurs en pourcentages pour que le graphique soit plus visibles

Enfin, on représente le ratio décès / réanimations :

1.3.2 Graphique d’évolution du nombre d’hospitalisations par départements groupés par région

On va s’intéresser au nombre d’hospitalisations. On peut représenter cette information département par département. Ici, on représente le nombre cummulé d’entrée par semaine en fonction du temps.

On représente d’abord les 4 régions actuellement les plus touchées et pour lesquelles l’axe des ordonnées va de 0 à 1200.

On représente ensuite les 8 régions suivantes les plus touchées mais avec une échelle différente sur l’axe des ordonnées (0 à 400):

Enfin, on représente les 2 régions les moins touchées et avec une échelle différente sur l’axe des ordonnées (0 à 200):

1.3.3 Cartes d’évolution sur les 6 dernières semaines

On représente l’évolution des hospitalisations sur les 6 dernières semaines:

On représente l’évolution des réanimations sur les 6 dernières semaines:

On représente l’évolution des décès sur les 6 dernières semaines:

1.4 Départements avec les plus fortes évolutions en valeurs absolues par rapport à la semaine précédente

On calcule la différence entre le nombre de nouveaux patients hospitalisés sur la période [24 novembre 2020; 30 novembre 2020] et sur la période [16 novembre 2020; 23 novembre 2020]

On va représenter des couleurs différentes en fonction du taux d’évolution découpées en 5 classes

  • taux d’évolution négatif
  • taux compris entre 0 et \(50\%\)
  • taux compris entre \(50\%\) et \(100\%\)
  • taux compris entre \(100\%\) et \(200\%\)
  • taux supérieur à \(200\%\)

2 Données relatives aux résultats des tests virologiques COVID-19

On met à jour les données chaque jour :

On va calculer quelques chiffres clés pour mesurer la situation des régions sur une fenêtre de 7 jours [21 novembre 2020; 27 novembre 2020]. On ne peut pas représenter les 7 derniers jours car les données ne sont pas encore diffusées.

On représente par région:

region total semaine moyenne jour evolution en %
Auvergne-Rhône-Alpes 12666 1809 -42.9
Ile-de-France 10462 1495 -37.2
Grand Est 6837 977 -33.4
Hauts-de-France 6781 969 -41.3
Provence-Alpes-Côte d’Azur 5349 764 -39.4
Nouvelle-Aquitaine 4574 653 -33.4
Bourgogne-Franche-Comté 4428 633 -35.8
Occitanie 4237 605 -39.7
Normandie 2681 383 -44.4
Pays de la Loire 2569 367 -44
Centre-Val de Loire 2430 347 -36.9
Bretagne 1319 188 -45.2
DOM-TOM 794 113 -36.2
Corse 89 13 -50
France entière 65216 9317 -39.3

2.1 Représentation des testés positifs par tranche d’âge en fonction du temps

On représente les testés positifs par tranche d’age:

On représente les testés positifs par région :

2.2 Graphique d’évolution du nombre de détectés positifs par départements groupés par région

2.3 Choix du décallage

Hypothèse: on suppose que le nombre d’admis en hospitalisations à la semaine t0 dépend du nombre de cas testés positifs sur une fenêtre de 7 jours qui aura commencé 10 jours avant la semaine t0. Exemple: la semaine t0 est [24 novembre 2020; 30 novembre 2020], on va l’expliquer par le nombre de personnes testées positive du [14 novembre 2020; 20 novembre 2020].

3 Préparation des données pour la modélisation

On prépare ici les données pour l’étape de modélisation:

3.1 Représentation du lien entre entre le nombre d’hospitalisations et le nombre de testés positifs

Dans un premier temps, on va rerésenter les départements par des cercles de taille proportionnelle aux nombres de testés positifs la semaine du [14 novembre 2020; 20 novembre 2020]. La couleur dépend du nombre d’hospitalisations observés la semaine du [24 novembre 2020; 30 novembre 2020].

On représente le nombre de nouvelles hospitalisations par semaine et par département en fonction du nombre de personnes testées positives quelques jours auparavant et on constate un lien très fort.

4 Prédire le nombre de testés positifs

On rappelle que les données sur le nombre de testés positifs ne sont disponible que jusqu’au 27 novembre 2020. Notre objectif est de prédire le nombre de testés positifs du 28 novembre 2020 au 04 décembre 2020 en utilisant des modèles de séries temporelles. En utilisant un modèle de série temporelle on suppose que ce qu’on observe à la date \(j\) dépend de ce qu’il s’est passé les dates antérieures. On va utiliser 3 modèles différents et en fonction de leur performence (sur les données passées), on va leur donner plus ou moins d’importance.

4.1 Modèle de type Box-Jenkins

Ici, on considère les données journalières, et non hebdomadaires. On va expliquer \(y_{d, t}^a\), le nombre de testés positifs le jour \(t\) dans le département \(d\) et dans la tranche d’âge \(a\). La stratégie utilisée est la suivante :

  • on différencie chaque série pour les rendre stationnaire (on ne vérifiera pas l’hypothèse de stationarité après la différenciation car on modélise énormément de modèle, ici on a \(A\times D\) séries où \(A\) est le nombre de classe d’âge et \(D\) le nombre de département et notre but est d’avoir une procédure automatique)

  • on cherche le meilleur modèle \(ARIMA(p,d,q)\) selon le critère AIC, à l’aide de la fonction auto.arima() (package forecast)

  • on prédit sur les 7 prochains jours à venir et on cummule ces prédictions pour avoir une prédiction du nombre de cas positifs sur la semaine à venir.

4.2 Modèle de type Lissage exponentiel

On va appliquer deux modèles de lissage exponentiels:

  • un modèle journalier qui va permettre de modéliser \(y_{d, t}^a\), le nombre de testés positifs le jour \(t\) dans le département \(d\) et dans la tranche d’âge \(a\) afin de prédire le nombre de testés positifs dans les 7 jours.

  • un modèle hebdomadaire qui va permettre de modéliser \(y_{d, s}^a\), le nombre de testés positifs la semaine \(s\) dans le département \(d\) et dans la tranche d’âge \(a\) afin de prédire le nombre de testés positifs la semaine à venir.

4.3 Combinaison des prédictions

On apprentit les modèles ci-dessus en enlevant la dernière semaine observée dans le but de donner des poids différents aux trois modèles de prédictions utilisés. Ainsi, on donnera davantage de poids aux modèles qui ont mieux prédit la dernière semaine observée.

# prediction par department 
nom_dep <- my_basis[my_basis$semaine == "semaine_t00", "dep"]
pred_cas <- numeric(length(nom_dep))
my_tab <- data.frame(true_P = numeric(0), pred_1 = numeric(0), pred_2 = numeric(0), pred_3 = numeric(0))
      
# apprentissage
for (k in length(nom_dep):1) {
  if (nom_dep[k] %in% c("975", "977", "978")) {
    my_basis <- rbind(data_k, my_basis)
  } else {
    for (age in c(0, 9, 19, 29, 39, 49, 59, 69, 79, 89, 90)) {
      
      # apprentissage
      temp <- test[test$dep == nom_dep[k] & test$cl_age90 == age & test$jour <= max(test$jour) - 7, ]
      my_ts <- zoo(temp$P, temp$jour)
      
      # Methode 1 : ARIMA
      my_ts_diff <- diff(my_ts)
      # tseries::adf.test(my_ts) 
      # tseries::adf.test(my_ts_diff)
      my_mod <- forecast::auto.arima(my_ts_diff)
      forecast_my_mod <- as.numeric(forecast(my_mod)$mean)
      pred_1 <- round(sum((as.numeric(my_ts[length(my_ts)]) + cumsum(forecast_my_mod))[1:7]), 0)
      # Méthode 2 : lissage exponentiel
      my_mod_exp <- ets(my_ts)
      forecast_my_mod_exp <- as.numeric(forecast(my_mod_exp)$mean)
      forecast_my_mod_exp <- ifelse(forecast_my_mod_exp > 0, forecast_my_mod_exp, 0)
      pred_2 <- round(sum(forecast_my_mod_exp[1:7]), 0)
      # Méthode 3 : lissage exponentiel sur données hebdomadaires
      temp <- my_basis[my_basis$dep == nom_dep[k] & !(my_basis$semaine %in% c("semaine_t0-1", "semaine_t0-2")), ]
      my_ts_exp <- zoo(temp[ , paste0("tranche_", age)], temp$jour)
      my_mod_exp_2 <- ets(my_ts_exp)
      forecast_my_mod_exp <- as.numeric(forecast(my_mod_exp_2)$mean)
      forecast_my_mod_exp <- ifelse(forecast_my_mod_exp > 0, forecast_my_mod_exp, 0)
      pred_3 <- round(forecast_my_mod_exp[1], 0)
      
      true_P <- sum(test[which(test$dep == nom_dep[k] & test$cl_age90 == age & 
                               test$jour > (max(test$jour) - 7)), "P"])
      my_tab <- rbind(my_tab, data.frame(true_P = true_P, pred_1 = pred_1, pred_2 = pred_2, pred_3 = pred_3))
    }
  }
}

res_lm_cas <- lm(true_P ~ pred_1 + pred_2 + pred_3, data = my_tab)

for (k in length(nom_dep):1) {
  data_k <- data.frame(dep = nom_dep[k], semaine = "semaine_t0-2", hosp = NA, rea = NA, rad = NA, dc = NA,
                         jour = to_day + 13, region = dep_region[match(nom_dep[k], dep_region$dep) , "region"],
                         tranche_9 = NA, tranche_19 = NA,  tranche_29 = NA,  tranche_39 = NA,  tranche_49 = NA, 
                         tranche_59 = NA,  tranche_69 = NA,  tranche_79 = NA,  tranche_89 = NA,  tranche_90 = NA, 
                         tranche_0  = NA)
  data_k_2 <- data.frame(dep = nom_dep[k], semaine = "semaine_t0-2", hosp = NA, rea = NA, rad = NA, dc = NA,
                         jour = to_day + 13, region = dep_region[match(nom_dep[k], dep_region$dep) , "region"],
                         tranche_9 = NA, tranche_19 = NA,  tranche_29 = NA,  tranche_39 = NA,  tranche_49 = NA, 
                         tranche_59 = NA,  tranche_69 = NA,  tranche_79 = NA,  tranche_89 = NA,  tranche_90 = NA, 
                         tranche_0  = NA)
      
  if (nom_dep[k] %in% c("975", "977", "978")) {
    my_basis <- rbind(data_k, my_basis)
  } else {
    for (age in c(0, 9, 19, 29, 39, 49, 59, 69, 79, 89, 90)) {
      # modèle journaliers 
      temp <- test[test$dep == nom_dep[k] & test$cl_age90 == age, ]
      my_ts <- zoo(temp$P, temp$jour)
      my_ts_diff <- diff(my_ts)
      # tseries::adf.test(my_ts) 
      # tseries::adf.test(my_ts_diff)
      my_mod <- forecast::auto.arima(my_ts_diff)
      forecast_my_mod <- as.numeric(forecast(my_mod)$mean)
      pred_1 <- round(sum((as.numeric(my_ts[length(my_ts)]) + cumsum(forecast_my_mod))[1:7]), 0)
      # modèles exponentiels
      # Méthode 2 : lissage exponentiel
      my_mod_exp <- ets(my_ts)
      forecast_my_mod_exp <- as.numeric(forecast(my_mod_exp)$mean)
      forecast_my_mod_exp <- ifelse(forecast_my_mod_exp > 0, forecast_my_mod_exp, 0)
      pred_2 <- round(sum(forecast_my_mod_exp[1:7]), 0)
      # Méthode 3 : lissage exponentiel sur données hebdomadaires
      temp <- my_basis[my_basis$dep == nom_dep[k] & !(my_basis$semaine %in% c("semaine_t0-2")), ]
      my_ts_exp <- zoo(temp[ , paste0("tranche_", age)], temp$jour)
      my_mod_exp_2 <- ets(my_ts_exp)
      forecast_my_mod_exp <- as.numeric(forecast(my_mod_exp_2)$mean)
      forecast_my_mod_exp <- ifelse(forecast_my_mod_exp > 0, forecast_my_mod_exp, 0)
      pred_3 <- round(forecast_my_mod_exp[1], 0)
      data_k[ , paste0("tranche_", age)] <- predict(res_lm_cas, newdata = data.frame(pred_1 = pred_1,
                                                                                     pred_2 = pred_2,
                                                                                     pred_3 = pred_3))
    }
    my_basis <- rbind(data_k, my_basis)
  }
}

On représente les testés positifs par région en ajoutant les valeurs de la semaine prédite:

On aggrège les données à la France entière:

5 Prédire le nombre d’hospitalisation de la semaine à venir

5.1 Modèle linéaire 1 (sur les départements) en fonction du nombre de cas détectés positifs : 1 modèle par région

Ici, pour chaque région \(r\), le modèle est de la forme

\[y_{i,t}^r=\beta_0^r+\beta_1^rx_{i,t'}^r+\epsilon_{i,t}^r\] avec:

  • \(y_{i,t}\) le nombre d’entrées à l’hôpital dans le département \(i\in r\) sur la période \(t\), où \(t\) est une fenêtre de 7 jours.
  • \(x_{i,t'}\) est le nombre de testés positifs dans le département \(i\in r\) sur la période \(t'\) où \(t'\) correspond à la fenêtre \(t\), décalé de 10 jours.

En d’autres termes, on fait ici un modèle de régression par région. Cela suppose que le lien entre les tests virologiques et le nombre d’hospitalisation est homogène à l’intérieur d’une région et peut différer d’une région à une autre.

Apprentissage:

On modélise sur les observations des semaines précédentes:

Dependent variable:
hosp
regionAuvergne-Rhône-Alpes 7.119***
(1.590)
regionBourgogne-Franche-Comté 3.429*
(1.972)
regionBretagne 1.414
(2.973)
regionCentre-Val de Loire 3.998*
(2.346)
regionCorse 1.224
(4.248)
regionDOM-TOM 1.824
(2.967)
regionGrand Est 8.943***
(1.761)
regionHauts-de-France 10.615***
(2.466)
regionIle-de-France 21.232***
(2.254)
regionNormandie 2.264
(2.550)
regionNouvelle-Aquitaine 1.124
(1.628)
regionOccitanie 0.974
(1.548)
regionPays de la Loire 6.975***
(2.597)
regionProvence-Alpes-Côte d’Azur 3.110
(2.316)
regionAuvergne-Rhône-Alpes:tranche_0 0.062***
(0.001)
regionBourgogne-Franche-Comté:tranche_0 0.070***
(0.002)
regionBretagne:tranche_0 0.050***
(0.004)
regionCentre-Val de Loire:tranche_0 0.053***
(0.004)
regionCorse:tranche_0 0.038*
(0.020)
regionDOM-TOM:tranche_0 0.113***
(0.008)
regionGrand Est:tranche_0 0.057***
(0.002)
regionHauts-de-France:tranche_0 0.053***
(0.001)
regionIle-de-France:tranche_0 0.056***
(0.001)
regionNormandie:tranche_0 0.066***
(0.002)
regionNouvelle-Aquitaine:tranche_0 0.056***
(0.002)
regionOccitanie:tranche_0 0.053***
(0.002)
regionPays de la Loire:tranche_0 0.046***
(0.002)
regionProvence-Alpes-Côte d’Azur:tranche_0 0.084***
(0.001)
Observations 2,727
R2 0.947
Adjusted R2 0.947
Residual Std. Error 26.292 (df = 2699)
F Statistic 1,725.368*** (df = 28; 2699)
Note: p<0.1; p<0.05; p<0.01

On représente comme si on on avait fait un modèle par région pour faciliter la lecture des coefficients :

Dependent variable:
hosp
Auvergne-Rhône-Alpes Hauts-de-France Provence-Alpes-Côte d’Azur Grand Est Occitanie Normandie Nouvelle-Aquitaine Centre-Val de Loire Bourgogne-Franche-Comté Bretagne Corse Pays de la Loire Ile-de-France DOM-TOM
(1) (2) (3) (4) (5) (6) (7) (8) (9) (10) (11) (12) (13) (14)
tranche_0 0.062*** 0.053*** 0.084*** 0.057*** 0.053*** 0.066*** 0.056*** 0.053*** 0.070*** 0.050*** 0.038*** 0.046*** 0.056*** 0.113***
(0.001) (0.001) (0.002) (0.001) (0.001) (0.002) (0.001) (0.002) (0.002) (0.002) (0.003) (0.001) (0.001) (0.007)
Constant 7.119*** 10.615*** 3.110 8.943*** 0.974 2.264 1.124 3.998*** 3.429** 1.414 1.224** 6.975*** 21.232*** 1.824
(2.025) (3.586) (4.391) (1.372) (0.698) (1.695) (0.768) (1.291) (1.572) (1.271) (0.567) (1.511) (3.776) (2.643)
Observations 324 135 162 270 351 135 324 162 216 108 54 135 216 135
R2 0.954 0.956 0.920 0.865 0.944 0.925 0.890 0.820 0.861 0.897 0.805 0.889 0.915 0.673
Adjusted R2 0.954 0.955 0.920 0.865 0.943 0.924 0.890 0.819 0.860 0.896 0.801 0.888 0.914 0.670
Residual Std. Error 33.479 (df = 322) 38.235 (df = 133) 49.852 (df = 160) 20.492 (df = 268) 11.862 (df = 349) 17.480 (df = 133) 12.405 (df = 322) 14.469 (df = 160) 20.964 (df = 214) 11.245 (df = 106) 3.507 (df = 52) 15.292 (df = 133) 44.049 (df = 214) 23.423 (df = 133)
F Statistic 6,656.497*** (df = 1; 322) 2,877.580*** (df = 1; 133) 1,842.185*** (df = 1; 160) 1,720.323*** (df = 1; 268) 5,843.826*** (df = 1; 349) 1,630.495*** (df = 1; 133) 2,608.848*** (df = 1; 322) 728.926*** (df = 1; 160) 1,324.861*** (df = 1; 214) 918.555*** (df = 1; 106) 214.939*** (df = 1; 52) 1,065.864*** (df = 1; 133) 2,297.019*** (df = 1; 214) 273.674*** (df = 1; 133)
Note: p<0.1; p<0.05; p<0.01

Test:

On teste le modèle sur les données de la semaine actuelle:

L’écart quadratique moyen est égal ici à :

## [1] 1891.08

5.2 Modèle linéaire 2 (sur les région) : 1 modèle par classe d’âge

Ici, on va faire un modèle qui prend en compte les classes d’âges. Les données d’hospitalisation par classe d’âge ne sont disponibles que par région. Le modèle est de la forme

\[y_{i,t}^a=\beta_0^a+\beta_1^ax_{i,t'}^a+\epsilon_{i,t}^a\] avec:

  • \(y_{i,t}\) le nombre d’entrées de la classe d’âge \(a\) à l’hôpital dans la région \(i\) sur la période \(t\), où \(t\) est une fenêtre de 7 jours.

  • \(x_{i,t'}\) est le nombre de testés positifs de la classe d’âge \(a\) dans la région \(i\) sur la période \(t'\) où \(t'\) correspond à la fenêtre \(t\), décalé de 10 jours.

En d’autres termes, on fait ici un modèle de régression par classe d’âge, toute région confondue. Cela suppose que le lien entre les tests virologiques et le nombre d’hospitalisation est homogène dans une classe d’âge quelque soit les régions.

On merge avec le nombre de test positifs:

Apprentissage:

On modélise sur les observations des semaines précédentes et on représente les résultats tranche d’âge par tranche d’âge

Dependent variable:
hosp_9 hosp_19 hosp_29 hosp_39 hosp_49 hosp_59 hosp_69 hosp_79 hosp_89 hosp_90
(1) (2) (3) (4) (5) (6) (7) (8) (9) (10)
tranche_9 0.020***
(0.001)
tranche_19 0.004***
(0.0002)
tranche_29 0.008***
(0.0002)
tranche_39 0.014***
(0.0003)
tranche_49 0.022***
(0.0004)
tranche_59 0.045***
(0.001)
tranche_69 0.104***
(0.001)
tranche_79 0.219***
(0.004)
tranche_89 0.338***
(0.006)
tranche_90 0.283***
(0.006)
Constant 0.894*** 1.015*** 2.791*** 3.944*** 4.410*** 5.103*** 7.599*** 9.885*** 14.144*** 8.807***
(0.277) (0.260) (0.475) (0.562) (0.678) (1.146) (1.511) (2.586) (2.902) (1.791)
Observations 378 378 378 378 378 378 378 378 378 378
R2 0.533 0.496 0.747 0.840 0.893 0.917 0.938 0.898 0.901 0.842
Adjusted R2 0.532 0.495 0.746 0.839 0.893 0.917 0.938 0.897 0.900 0.842
Residual Std. Error (df = 376) 4.750 4.518 8.219 9.926 12.002 20.304 26.789 45.924 51.838 32.178
F Statistic (df = 1; 376) 429.757*** 370.016*** 1,110.219*** 1,968.160*** 3,143.473*** 4,174.765*** 5,682.281*** 3,296.041*** 3,410.406*** 2,008.546***
Note: p<0.1; p<0.05; p<0.01

Test:

On teste le modèle sur les données de la semaine actuelle. On revient sur les données départementales, on suppose donc que les modèles estimés pour chaque tranche d’âge sur les régions est valable aussi pour les départements.

On a donc une prédiction par tranche d’âge et pour obtenir la prédiction finale, il faut donc faire la somme sur les différentes prédictions :

L’écart quadratique moyen est égal ici à :

## [1] 3855.127

5.3 Modèle de série temporelle

On utilise la même stratégie que celle présentée pour prédire le nombre de cas positifs.

Etape d’apprentissage : on entraîne l’agorithme sur les données passées en enlevant la dernière semaine observée et on prédit sur cette semaine afin de calculer les écarts quadratiques avec les valeurs observées.

On obtient le graphique suivant de valeurs prédites/valeurs observées :

L’écart quadratique moyen est égal ici à :

## [1] 1721.503 1163.782 3591.525

Les 3 prédictions sont très proches et on va choisir un algorithme de type stepwise sur les prédictions pour choisir la meilleure combinaison des modèles de séries temporelles.

## Start:  AIC=646.18
## my_basis[my_basis$semaine == "semaine_t00", "hosp"] ~ pred_3a + 
##     pred_3b + pred_3c - 1
## 
##           Df Sum of Sq   RSS    AIC
## - pred_3b  1        96 57255 644.35
## - pred_3a  1       253 57412 644.63
## <none>                 57159 646.18
## - pred_3c  1     32019 89177 689.11
## 
## Step:  AIC=644.35
## my_basis[my_basis$semaine == "semaine_t00", "hosp"] ~ pred_3a + 
##     pred_3c - 1
## 
##           Df Sum of Sq   RSS    AIC
## - pred_3a  1       567 57822 643.35
## <none>                 57255 644.35
## - pred_3c  1     37946 95201 693.71
## 
## Step:  AIC=643.35
## my_basis[my_basis$semaine == "semaine_t00", "hosp"] ~ pred_3c - 
##     1
## 
##           Df Sum of Sq     RSS    AIC
## <none>                   57822 643.35
## - pred_3c  1   1610505 1668327 980.93
## [1] 572.4945

On a donc 3 prédictions obtenues selon :

  • modèle par région
  • modèle par classe d’âge
  • modèle de séries temporelles (lui-même combinaison de plusieurs méthodes)

5.4 Combinaison des prédictions

Combinaison des prédictions:

  • pour prédire les nouvelles hospitalisations la semaine à venir, on va faire un panaché des trois prédictions en donnant plus de poids à la prédiction qui a le mieux marcher sur la semaine \(t_0\). Autrement dit, on fait un modèle linéaire (avec une procédure stepwise) du nombre d’hospitalisation en fonction des 3 méthodes de prédictions. On calcule l’écart quatratique moyen de la combinaison des prédictions.
## [1] 493.0658
  • pour prédire les nouvelles hospitalisations la semaine d’après, on va utiliser une autre pondération en utilisant la même procédure que précédemment, mais dans une optique de prédire à deux semaines.
## Start:  AIC=1450.13
## y_true ~ pred_3a_s2 + pred_3b_s2 + pred_3c_s2 - 1
## 
## 
## Step:  AIC=1450.13
## y_true ~ pred_3a_s2 + pred_3b_s2 - 1
## 
## 
## Step:  AIC=1450.13
## y_true ~ pred_3a_s2 - 1
## 
##              Df Sum of Sq     RSS    AIC
## <none>                     262301 1450.1
## - pred_3a_s2  1   4657744 4920045 2040.3

5.5 Prédiction

On prédit le nombre d’hospitalisations :

  • du [01 décembre 2020; 07 décembre 2020] en utilisant les vrais valeurs du nombre de testé positifs la semaine du [21 novembre 2020; 27 novembre 2020].

  • du [08 décembre 2020; 14 décembre 2020] en utilisant les valeurs prédites du nombre de testé positifs la semaine du [28 novembre 2020; 04 décembre 2020].

Avant de faire cela, on actualise en incluant dans l’étape d’apprentissage les données de la dernière semaine observée:

# modèle 1
res_lm <- lm(hosp ~  tranche_0, data = my_basis[!(my_basis$semaine %in% "semaine_t0-1"), ])
# modèle 2
apprentissage_sample <- my_basis_age_wide[!(my_basis_age_wide$semaine %in% 
                                              c("semaine_t0-1")), ]
res_lm_9 <- lm(hosp_9 ~  tranche_9, data = apprentissage_sample)
res_lm_19 <- lm(hosp_19 ~  tranche_19, data = apprentissage_sample)
res_lm_29 <- lm(hosp_29 ~  tranche_29, data = apprentissage_sample)
res_lm_39 <- lm(hosp_39 ~  tranche_39, data = apprentissage_sample)
res_lm_49 <- lm(hosp_49 ~  tranche_49, data = apprentissage_sample)
res_lm_59 <- lm(hosp_59 ~  tranche_59, data = apprentissage_sample)
res_lm_69 <- lm(hosp_69 ~  tranche_69, data = apprentissage_sample)
res_lm_79 <- lm(hosp_79 ~  tranche_79, data = apprentissage_sample)
res_lm_89 <- lm(hosp_89 ~  tranche_89, data = apprentissage_sample)
res_lm_90 <- lm(hosp_90 ~  tranche_90, data = apprentissage_sample)

# On prédit avec la méthode 1 
new_data <- my_basis[my_basis$semaine %in% c("semaine_t0-1", "semaine_t0-2"), ]
pred_1 <- predict(res_lm, newdata = new_data)
# On prédit avec la méthode 2
test_sample <- my_basis[my_basis$semaine %in% c("semaine_t0-1", "semaine_t0-2"), ]
pred_9 <- predict(res_lm_9, newdata = test_sample)
pred_19 <- predict(res_lm_19, newdata = test_sample)
pred_29 <- predict(res_lm_29, newdata = test_sample)
pred_39 <- predict(res_lm_39, newdata = test_sample)
pred_49 <- predict(res_lm_49, newdata = test_sample)
pred_59 <- predict(res_lm_59, newdata = test_sample)
pred_69 <- predict(res_lm_69, newdata = test_sample)
pred_79 <- predict(res_lm_79, newdata = test_sample)
pred_89 <- predict(res_lm_89, newdata = test_sample)
pred_90 <- predict(res_lm_90, newdata = test_sample)
pred_2 <- pred_9 + pred_19 + pred_29 + pred_39 + pred_49 + pred_59 + pred_69 + 
  pred_79 + pred_89 + pred_90

# on prédit avec le modèle 3, mais on actualise les prédictions semaine par semaine
pred_3 <- matrix(0, length(nom_dep), 2)
for (k in 1:length(nom_dep)) {
 if (nom_dep[k] %in% c("975", "977", "978")) {
    pred_3[k, ] <- NA
  } else {
    temp <- hospital[!(hospital$semaine %in% c("semaine_t0-2", "semaine_t0-1")) & 
                     hospital$dep == nom_dep[k], ]
    my_ts <- zoo(temp$incid_hosp, temp$jour)
    my_ts_diff <- diff(my_ts)
    # tseries::adf.test(my_ts) 
    # tseries::adf.test(my_ts_diff)
    # predictions à 7 jours
    my_mod <- forecast::auto.arima(my_ts_diff)
    forecast_my_mod <- as.numeric(forecast(my_mod, h = 14)$mean)
    pred_3a_s1 <- sum((as.numeric(my_ts[length(my_ts)]) + cumsum(forecast_my_mod))[1:7])
    # prediction à 14 jours
    pred_3a_s2 <- sum((as.numeric(my_ts[length(my_ts)]) + cumsum(forecast_my_mod))[1:14]) - pred_3a_s1
    # Lissage exponentiel
    my_mod_exp <- ets(my_ts)
    forecast_my_mod_exp <- as.numeric(forecast(my_mod_exp, h = 14)$mean)
    forecast_my_mod_exp <- ifelse(forecast_my_mod_exp > 0, forecast_my_mod_exp, 0)
    pred_3b_s1 <- round(sum(forecast_my_mod_exp[1:7]), 0)
    pred_3b_s2 <- round(sum(forecast_my_mod_exp[1:14]), 0) - pred_3b_s1
    # Méthode 3 : lissage exponentiel sur données hebdomadaires
    temp <- my_basis[my_basis$dep == nom_dep[k] & !(my_basis$semaine %in% 
                                          c("semaine_t0-2", "semaine_t0-1")), ]
    my_ts_exp <- zoo(temp$hosp, temp$jour)
    my_mod_exp_2 <- ets(my_ts_exp)
    forecast_my_mod_exp <- as.numeric(forecast(my_mod_exp_2)$mean)
    forecast_my_mod_exp <- ifelse(forecast_my_mod_exp > 0, forecast_my_mod_exp, 0)
    pred_3c_s1 <- round(forecast_my_mod_exp[1], 0)
    pred_3c_s2 <- round(forecast_my_mod_exp[2], 0)
    
    # prédictions des time series
    pred_3[k, 1] <- predict(lm_3_ts, newdata = data.frame(pred_3a = pred_3a_s1,
                                                 pred_3b = pred_3b_s1,
                                                 pred_3c = pred_3c_s1))
    
    # prediction à 14 jours
    pred_3[k, 2] <- predict(lm_3b_ts, newdata = data.frame(pred_3a_s2 = pred_3a_s2,
                                                 pred_3b_s2 = pred_3b_s2,
                                                 pred_3c_s2 = pred_3c_s2))
  }
}
pred_3 <- as.vector(pred_3)
# On fait le mélande des deux prédictions
res_pred_a <- predict(lm_3, newdata = data.frame(pred_1 = pred_1[new_data$semaine == "semaine_t0-1"], 
                                               pred_2 = pred_2[test_sample$semaine == "semaine_t0-1"],
                                               pred_3 = pred_3[1:(length(pred_3) / 2)]))
res_pred_b <- predict(lm_3b, newdata = data.frame(
  pred_1_s2 = pred_1[new_data$semaine == "semaine_t0-2"],
  pred_2_s2 = pred_2[test_sample$semaine == "semaine_t0-2"],
  pred_3_s2 = pred_3[((length(pred_3) / 2) + 1):length(pred_3)]))
new_data <- my_basis[my_basis$semaine %in% "semaine_t0-1", ]
my_basis[my_basis$semaine %in% "semaine_t0-1", "hosp"] <- res_pred_a
my_basis[my_basis$semaine %in% "semaine_t0-2", "hosp"] <- res_pred_b
new_data$next_week <- res_pred_a
new_data$next_two_week <- res_pred_b

On va représenter l’évolution du nombre de nouveaux patients hospitalisés dans un intervalle de temps de 4 semaines :

  • la semaine du [17 novembre 2020; 23 novembre 2020]
  • les 7 derniers jours passés : [24 novembre 2020; 30 novembre 2020]
  • la semaine à venir : [01 décembre 2020; 07 décembre 2020]
  • la semaine suivante à venir : [08 décembre 2020; 14 décembre 2020]

On aggrège les données à la France entière:

6 Prédire le nombre de réanimations

L’idée est d’expliquer le nombre de nouvelles réanimations la semaine \(t\) par le nombre de nouvelles hospitalisations la semaine \(t-1\).

Ainsi on sera en mesure de prédire le nombre de nouvelles réanimations d’une part la semaine à venir, mais aussi la semaine d’après si on utilise les prédictions du nombre d’hospitalisation la semaine à venir.

On prépare les données et on représente le nombre de nouvelles réanimations par semaine et par département en fonction du nombre de nouvelles hospitalisations la semaine d’avant et on constate un lien très fort.

On ne va faire que deux modèles :

On n’utilise pas le modèle qui utilise les classes d’âges car c’est difficile d’avoir le nombre de nouvelles réanimations par jour/département par classe d’âge. Il se peut donc que les prédictions soient sous-estimées dans le cas où la distribution des patients hospitalisés agés évolue positivement au cours du temps.

6.1 Modèle 1 : modèle linéaire

Apprentissage:

On modélise sur les observations des semaines précédentes:

Dependent variable:
rea
regionAuvergne-Rhône-Alpes 0.107
(0.408)
regionBourgogne-Franche-Comté 0.606
(0.503)
regionBretagne 0.847
(0.752)
regionCentre-Val de Loire 0.305
(0.608)
regionCorse 0.265
(1.117)
regionDOM-TOM 2.041***
(0.720)
regionGrand Est 0.065
(0.470)
regionHauts-de-France 0.739
(0.637)
regionIle-de-France -0.005
(0.597)
regionNormandie 0.378
(0.647)
regionNouvelle-Aquitaine 0.302
(0.412)
regionOccitanie 0.320
(0.393)
regionPays de la Loire 0.560
(0.690)
regionProvence-Alpes-Côte d’Azur 0.198
(0.585)
regionAuvergne-Rhône-Alpes:hosp 0.151***
(0.002)
regionBourgogne-Franche-Comté:hosp 0.131***
(0.009)
regionBretagne:hosp 0.129***
(0.019)
regionCentre-Val de Loire:hosp 0.171***
(0.016)
regionCorse:hosp 0.162
(0.117)
regionDOM-TOM:hosp 0.095***
(0.014)
regionGrand Est:hosp 0.152***
(0.008)
regionHauts-de-France:hosp 0.187***
(0.003)
regionIle-de-France:hosp 0.188***
(0.003)
regionNormandie:hosp 0.139***
(0.009)
regionNouvelle-Aquitaine:hosp 0.145***
(0.010)
regionOccitanie:hosp 0.205***
(0.007)
regionPays de la Loire:hosp 0.148***
(0.013)
regionProvence-Alpes-Côte d’Azur:hosp 0.153***
(0.003)
Observations 2,626
R2 0.889
Adjusted R2 0.888
Residual Std. Error 6.599 (df = 2598)
F Statistic 745.243*** (df = 28; 2598)
Note: p<0.1; p<0.05; p<0.01

Test:

On teste le modèle sur les données de la semaine actuelle:

L’écart quadratique moyen est égal ici à :

## [1] 144.5481

6.2 Modèle 2 : série temporelle

On utilise la même stratégie que celle présentée pour prédire le nombre de nouveaux cas positifs et de nouvelles réanimations.

Etape d’apprentissage : on entraîne l’agorithme sur les données passées en enlevant la dernière semaine observée et on prédit sur cette semaine afin de calculer les écarts quadratiques avec les valeurs observées.

On observe le graphique des valeurs prédites/valeurs observées :

L’écart quadratique moyen est égal ici à :

## [1]  66.00836  46.31683 172.02970

Les 3 prédictions sont très proches et on va choisir un algorithme de type stepwise sur les prédictions pour choisir la meilleure combinaison et ne conserver qu’une seule prédiction basée sur les séries temporelles:

## Start:  AIC=320.51
## my_basis[my_basis$semaine == "semaine_t00", "rea"] ~ pred_rea_2a + 
##     pred_rea_2b + pred_rea_2c - 1
## 
##               Df Sum of Sq    RSS    AIC
## - pred_rea_2b  1     28.70 2302.3 319.78
## - pred_rea_2a  1     36.80 2310.4 320.13
## <none>                     2273.6 320.51
## - pred_rea_2c  1    772.48 3046.0 348.05
## 
## Step:  AIC=319.78
## my_basis[my_basis$semaine == "semaine_t00", "rea"] ~ pred_rea_2a + 
##     pred_rea_2c - 1
## 
##               Df Sum of Sq    RSS    AIC
## <none>                     2302.3 319.78
## - pred_rea_2a  1    162.68 2464.9 324.68
## - pred_rea_2c  1   1104.58 3406.8 357.36
## [1] 22.79468

6.3 Combinaison des prédictions

Combinaison des prédictions: on peut envisager de faire un panaché des deux prédictions. Autrement dit, on fait un modèle linéaire (avec une procédure stepwise) du nombre de réanimations observée la semaine t0 en fonction des 2 méthodes de prédictions. On obtient l’écart-quadratique moyen suivant:

## [1] 22.12525

On adapte le poids des prédictions en fonction de la semaine à prédire

semaine_to_drop <- c("semaine_t0-3", "semaine_t0-2", "semaine_t0-1", "semaine_t00")
pred_rea_1_s2 <- numeric(0)
pred_rea_2a_s2 <- numeric(0)
pred_rea_2b_s2 <- numeric(0)
pred_rea_2c_s2 <- numeric(0)
pred_rea_1_s3 <- numeric(0)
pred_rea_2a_s3 <- numeric(0)
pred_rea_2b_s3 <- numeric(0)
pred_rea_2c_s3 <- numeric(0)

y_true <- numeric(0)

for (j in 0:1) {
  
  semaine_to_estim <-  paste0("semaine_t0", j)
  y_true <- c(y_true, my_basis[my_basis$semaine == semaine_to_estim, "rea"])
  semaine_to_drop <- c(semaine_to_drop, paste0("semaine_t0", j + 1))
  res_lm_rea_1 <- lm(rea ~  region + hosp:region - 1, 
             data = my_basis_rea[!(my_basis_rea$semaine %in% semaine_to_drop), ])
  pred_rea_1_s2 <- c(pred_rea_1_s2, 
     round(predict(res_lm_rea_1, newdata = my_basis_rea[my_basis_rea$semaine == semaine_to_estim, ])))
  pred_rea_2a_temp <- numeric(length(nom_dep))
  pred_rea_2b_temp <- numeric(length(nom_dep))
  pred_rea_2c_temp <- numeric(length(nom_dep))

  for (k in 1:length(nom_dep)) {
    temp <- hospital[!(hospital$semaine %in% semaine_to_drop) & 
                     hospital$dep == nom_dep[k], ]
    my_ts <- zoo(temp$incid_rea, temp$jour)
    my_ts_diff <- diff(my_ts)
    # tseries::adf.test(my_ts) 
    # tseries::adf.test(my_ts_diff)
    if (nom_dep[k] %in% c("975", "977", "978")) {
      pred_rea_2[k] <- NA
    } else {
      my_mod <- forecast::auto.arima(my_ts_diff)
      forecast_my_mod <- as.numeric(forecast(my_mod, h = 14)$mean)
      temp <- sum((as.numeric(my_ts[length(my_ts)]) + cumsum(forecast_my_mod))[1:7])
      pred_rea_2a_temp[k] <- sum((as.numeric(my_ts[length(my_ts)]) + cumsum(forecast_my_mod))[1:14]) - temp
      # modèles exponentiels
      # Méthode 2 : lissage exponentiel
      my_mod_exp <- ets(my_ts)
      forecast_my_mod_exp <- as.numeric(forecast(my_mod_exp, h = 14)$mean)
      forecast_my_mod_exp <- ifelse(forecast_my_mod_exp > 0, forecast_my_mod_exp, 0)
      temp <- round(sum(forecast_my_mod_exp[1:7]), 0)
      pred_rea_2b_temp[k] <- round(sum(forecast_my_mod_exp[1:14]), 0) - temp
      # Méthode 3 : lissage exponentiel sur données hebdomadaires
      temp <- my_basis[my_basis$dep == nom_dep[k] & !(my_basis$semaine %in% semaine_to_drop), ]
      my_ts_exp <- zoo(temp$rea, temp$jour)
      if (all(my_ts_exp == 0)) {
        pred_rea_2c_temp[k] <- 0
      } else {
        my_mod_exp_2 <- ets(my_ts_exp)
        forecast_my_mod_exp <- as.numeric(forecast(my_mod_exp_2)$mean)
        forecast_my_mod_exp <- ifelse(forecast_my_mod_exp > 0, forecast_my_mod_exp, 0)
        pred_rea_2c_temp[k] <- round(forecast_my_mod_exp[2], 0)
      }
    }
    
  }
   pred_rea_2a_s2 <- c(pred_rea_2a_s2, pred_rea_2a_temp)
   pred_rea_2b_s2 <- c(pred_rea_2b_s2, pred_rea_2b_temp)
   pred_rea_2c_s2 <- c(pred_rea_2c_s2, pred_rea_2c_temp)
}


lm_2_rea_ts_s1 <- step(lm(y_true ~ pred_rea_2a_s2 + pred_rea_2b_s2 + pred_rea_2c_s2 - 1))
## Start:  AIC=803.84
## y_true ~ pred_rea_2a_s2 + pred_rea_2b_s2 + pred_rea_2c_s2 - 1
## 
##                  Df Sum of Sq   RSS    AIC
## - pred_rea_2b_s2  1     67.76 10556 803.14
## <none>                        10488 803.84
## - pred_rea_2a_s2  1    594.45 11082 812.98
## - pred_rea_2c_s2  1   1161.17 11649 823.05
## 
## Step:  AIC=803.14
## y_true ~ pred_rea_2a_s2 + pred_rea_2c_s2 - 1
## 
##                  Df Sum of Sq   RSS    AIC
## <none>                        10556 803.14
## - pred_rea_2c_s2  1    1232.5 11788 823.45
## - pred_rea_2a_s2  1    2134.7 12690 838.35
pred_rea_2_s2 <- predict(lm_2_rea_ts_s1)

lm_rea_3b <- lm(y_true ~ pred_rea_1_s2 + pred_rea_2_s2 - 1)



#######

semaine_to_drop <- c("semaine_t0-3", "semaine_t0-2", "semaine_t0-1", "semaine_t00", "semaine_t01")
pred_rea_1_s3 <- numeric(0)
pred_rea_2a_s3 <- numeric(0)
pred_rea_2b_s3 <- numeric(0)
pred_rea_2c_s3 <- numeric(0)

y_true <- numeric(0)

for (j in 0:1) {
  
  semaine_to_estim <-  paste0("semaine_t0", j)
  y_true <- c(y_true, my_basis[my_basis$semaine == semaine_to_estim, "rea"])
  semaine_to_drop <- c(semaine_to_drop, paste0("semaine_t0", j + 2))
  
  res_lm_rea_1 <- lm(rea ~  region + hosp:region - 1, 
             data = my_basis_rea[!(my_basis_rea$semaine %in% semaine_to_drop), ])
  pred_rea_1_s3 <- c(pred_rea_1_s3, round(predict(res_lm_rea_1, newdata = my_basis_rea[my_basis_rea$semaine == semaine_to_estim, ])))
  
  pred_rea_2a_temp <- numeric(length(nom_dep))
  pred_rea_2b_temp <- numeric(length(nom_dep))
  pred_rea_2c_temp <- numeric(length(nom_dep))

  for (k in 1:length(nom_dep)) {
     temp <- hospital[!(hospital$semaine %in% semaine_to_drop) & hospital$dep == nom_dep[k], ]
     my_ts <- zoo(temp$incid_rea, temp$jour)
     my_ts_diff <- diff(my_ts)
     # tseries::adf.test(my_ts) 
     # tseries::adf.test(my_ts_diff)
     if (nom_dep[k] %in% c("975", "977", "978")) {
       pred_rea_2[k] <- NA
     } else {
       my_mod <- forecast::auto.arima(my_ts_diff)
       forecast_my_mod <- as.numeric(forecast(my_mod, h = 21)$mean)
       temp1 <- sum((as.numeric(my_ts[length(my_ts)]) + cumsum(forecast_my_mod))[1:7])
       temp2 <- sum((as.numeric(my_ts[length(my_ts)]) + cumsum(forecast_my_mod))[1:14]) - temp1
       pred_rea_2a_temp[k] <- sum((as.numeric(my_ts[length(my_ts)]) + cumsum(forecast_my_mod))[1:21]) - temp1 - temp2
       # modèles exponentiels
       # Méthode 2 : lissage exponentiel
       my_mod_exp <- ets(my_ts)
       forecast_my_mod_exp <- as.numeric(forecast(my_mod_exp, h = 21)$mean)
       forecast_my_mod_exp <- ifelse(forecast_my_mod_exp > 0, forecast_my_mod_exp, 0)
       temp1 <- round(sum(forecast_my_mod_exp[1:7]), 0)
       temp2 <- round(sum(forecast_my_mod_exp[1:14]), 0) - temp1
       pred_rea_2b_temp[k] <- round(sum(forecast_my_mod_exp[1:21]), 0) - temp2 - temp1
       # Méthode 3 : lissage exponentiel sur données hebdomadaires
       temp <- my_basis[my_basis$dep == nom_dep[k] & !(my_basis$semaine %in% semaine_to_drop), ]
       my_ts_exp <- zoo(temp$rea, temp$jour)
       if (all(my_ts_exp == 0)) {
         pred_rea_2c_temp[k] <- 0
       } else {
         my_mod_exp_2 <- ets(my_ts_exp)
         forecast_my_mod_exp <- as.numeric(forecast(my_mod_exp_2)$mean)
         forecast_my_mod_exp <- ifelse(forecast_my_mod_exp > 0, forecast_my_mod_exp, 0)
         pred_rea_2c_temp[k] <- round(forecast_my_mod_exp[3], 0)
       }
    }
}

  pred_rea_2a_s3 <- c(pred_rea_2a_s3, pred_rea_2a_temp)
  pred_rea_2b_s3 <- c(pred_rea_2b_s3, pred_rea_2b_temp)
  pred_rea_2c_s3 <- c(pred_rea_2c_s3, pred_rea_2c_temp)
}

lm_2_rea_ts_s2 <- step(lm(y_true ~ pred_rea_2a_s3 + pred_rea_2b_s3 + pred_rea_2c_s3 - 1))
## Start:  AIC=939.18
## y_true ~ pred_rea_2a_s3 + pred_rea_2b_s3 + pred_rea_2c_s3 - 1
## 
##                  Df Sum of Sq   RSS    AIC
## - pred_rea_2c_s3  1     84.93 20581 938.02
## - pred_rea_2b_s3  1    131.93 20628 938.48
## <none>                        20496 939.18
## - pred_rea_2a_s3  1   1513.73 22010 951.58
## 
## Step:  AIC=938.02
## y_true ~ pred_rea_2a_s3 + pred_rea_2b_s3 - 1
## 
##                  Df Sum of Sq   RSS    AIC
## <none>                        20581 938.02
## - pred_rea_2b_s3  1    255.71 20837 938.51
## - pred_rea_2a_s3  1   1637.30 22218 951.48

6.4 Prédiction

On prédit:

  • le nombre de réanimations à venir du [01 décembre 2020; 07 décembre 2020] en utilisant les nouvelles hospitalisations du [24 novembre 2020; 30 novembre 2020]

  • le nombre de réanimations à venir du [08 décembre 2020; 14 décembre 2020] en utilisant la prédiction des hospitalisations à venir du [01 décembre 2020; 07 décembre 2020]

  • le nombre de réanimations à venir du [15 décembre 2020; 21 décembre 2020] en utilisant la prédiction des hospitalisations à venir du [08 décembre 2020; 14 décembre 2020]

Pour cela, on actualise le modèle, c’est-à-dire qu’on inclut la dernière semaine observée:

res_lm <- lm(rea ~  region + hosp:region - 1, 
             data = my_basis_rea[!(my_basis_rea$semaine %in% c("semaine_t0-2", "semaine_t0-1")), ])

# semaine t+1
new_data_rea_1 <- my_basis_rea[my_basis_rea$semaine %in% c("semaine_t0-1", "semaine_t0-2", "semaine_t0-3"),  ]
pred_rea_1 <- predict(res_lm, newdata = new_data_rea_1)

pred_rea_2 <- matrix(0, length(nom_dep), 3)
pred_rea_2a <- matrix(0, length(nom_dep), 3)
pred_rea_2b <- matrix(0, length(nom_dep), 3)
pred_rea_2c <- matrix(0, length(nom_dep), 3)
for (k in 1:length(nom_dep)) {
  temp <- hospital[!(hospital$semaine %in% c("semaine_t0-3", "semaine_t0-2", "semaine_t0-1")) & 
                     hospital$dep == nom_dep[k], ]
  my_ts <- zoo(temp$incid_rea, temp$jour)
  my_ts_diff <- diff(my_ts)
  # tseries::adf.test(my_ts) 
  # tseries::adf.test(my_ts_diff)
  if (nom_dep[k] %in% c("975", "977", "978")) {
    pred_rea_2[k] <- NA
  } else {
    my_mod <- forecast::auto.arima(my_ts_diff)
    forecast_my_mod <- as.numeric(forecast(my_mod, h = 21)$mean)
    pred_3a_s1 <- sum((as.numeric(my_ts[length(my_ts)]) + cumsum(forecast_my_mod))[1:7])
    pred_3a_s2 <- sum((as.numeric(my_ts[length(my_ts)]) + cumsum(forecast_my_mod))[1:14]) - pred_3a_s1
    pred_3a_s3 <- sum((as.numeric(my_ts[length(my_ts)]) + cumsum(forecast_my_mod))[1:21]) - 
      pred_3a_s1 - pred_3a_s2
    # Lissage exponentiel
    my_mod_exp <- ets(my_ts)
    forecast_my_mod_exp <- as.numeric(forecast(my_mod_exp, h = 21)$mean)
    forecast_my_mod_exp <- ifelse(forecast_my_mod_exp > 0, forecast_my_mod_exp, 0)
    pred_3b_s1 <- round(sum(forecast_my_mod_exp[1:7]), 0)
    pred_3b_s2 <- round(sum(forecast_my_mod_exp[1:14]), 0) - pred_3b_s1
    pred_3b_s3 <- round(sum(forecast_my_mod_exp[1:21]), 0) - pred_3b_s2 - pred_3b_s1
    # Méthode 3 : lissage exponentiel sur données hebdomadaires
    temp <- my_basis[my_basis$dep == nom_dep[k] & !(my_basis$semaine %in% 
                                          c("semaine_t0-3", "semaine_t0-2", "semaine_t0-1")), ]
    my_ts_exp <- zoo(temp$rea, temp$jour)
    my_mod_exp_2 <- ets(my_ts_exp)
    forecast_my_mod_exp <- as.numeric(forecast(my_mod_exp_2)$mean)
    forecast_my_mod_exp <- ifelse(forecast_my_mod_exp > 0, forecast_my_mod_exp, 0)
    pred_3c_s1 <- round(forecast_my_mod_exp[1], 0)
    pred_3c_s2 <- round(forecast_my_mod_exp[2], 0)
    pred_3c_s3 <- round(forecast_my_mod_exp[3], 0)    
    
    pred_rea_2[k, 1] <- predict(lm_2_rea_ts, newdata = data.frame(pred_rea_2a = pred_3a_s1,
                                                 pred_rea_2b = pred_3b_s1,
                                                 pred_rea_2c = pred_3c_s1))
    pred_rea_2[k, 2] <- predict(lm_2_rea_ts_s1, newdata = data.frame(pred_rea_2a_s2 = pred_3a_s2,
                                                 pred_rea_2b_s2 = pred_3b_s2,
                                                 pred_rea_2c_s2 = pred_3c_s2))
    pred_rea_2[k, 3] <- predict(lm_2_rea_ts_s2, newdata = data.frame(pred_rea_2a_s3 = pred_3a_s3,
                                                 pred_rea_2b_s3 = pred_3b_s3,
                                                 pred_rea_2c_s3 = pred_3c_s3))
  }
}

pred_rea_a <- predict(lm_rea_3, newdata = data.frame(pred_rea_1 = 
                        pred_rea_1[new_data_rea_1$semaine == "semaine_t0-1"],
                        pred_rea_2 = as.vector(pred_rea_2)[1:(length(pred_rea_1) / 3)]))

pred_rea_b <- predict(lm_rea_3b, newdata = data.frame(
  pred_rea_1_s2 = pred_rea_1[new_data_rea_1$semaine == "semaine_t0-2"],
  pred_rea_2_s2 = as.vector(pred_rea_2)[((length(pred_rea_1) / 3) + 1):(2 * length(pred_rea_1) / 3)]))

pred_rea_c <- predict(lm_rea_3c, newdata = data.frame(
  pred_rea_1_s3 = pred_rea_1[new_data_rea_1$semaine == "semaine_t0-3"],
  pred_rea_2_s3 = as.vector(pred_rea_2)[(2 * length(pred_rea_1) / 3 + 1):length(pred_rea_1)]))

# on synthétise les résultats
new_data <- my_basis[my_basis$semaine %in% "semaine_t0-1", ]
new_data$this_week <- my_basis_rea[my_basis_rea$semaine == "semaine_t00", "rea"]
new_data$next_week <- pred_rea_a
new_data$next_two_week <- pred_rea_b
new_data$next_three_week <- pred_rea_c
my_basis[my_basis$semaine %in% "semaine_t0-1", "rea"] <- pred_rea_a
my_basis[my_basis$semaine %in% "semaine_t0-2", "rea"] <- pred_rea_b
my_basis[my_basis$semaine %in% "semaine_t0-3", "rea"] <- pred_rea_c

On va représenter l’évolution du nombre de patients en réanimations dans un intervalle de temps de 4 semaines :

  • les 7 derniers jours passés : [24 novembre 2020; 30 novembre 2020]
  • la semaine à venir : [01 décembre 2020; 07 décembre 2020]
  • la 2ème semaine à venir : [08 décembre 2020; 14 décembre 2020]
  • la 3ème semaine à venir : [15 décembre 2020; 21 décembre 2020]

On aggrège les données à la France entière:

7 Prédire le nombre de décès

L’idée est d’expliquer le nombre de nouveaux décès la semaine \(t\) par les nouvelles réanimations la semaine \(t-1\).

Ainsi on sera en mesure de prédire le nombre de nouveaux décès la semaine à venir, mais aussi les trois semaines suivantes en utilisant les prédictions des hospitalisations, des réanimations et cas positifs.

On prépare les données et on représente le nombre de nouveaux décès par semaine et par département en fonction du nombre de nouvelles réanimations la semaine d’avant et on constate un lien très fort.

On va faire deux modèles : un modèle régional où on explique les nouvelles réanimations des départements au sein d’une même région ainsi qu’un modèle de série temporelle département par département.

7.1 Modèle 1 : modèle linéaire

Apprentissage:

On modélise sur les observations des semaines précédentes:

Dependent variable:
dc
regionAuvergne-Rhône-Alpes 1.877***
(0.370)
regionBourgogne-Franche-Comté 1.034**
(0.457)
regionBretagne 0.213
(0.693)
regionCentre-Val de Loire 1.355**
(0.540)
regionCorse 0.094
(1.005)
regionDOM-TOM -0.487
(0.701)
regionGrand Est 1.143***
(0.425)
regionHauts-de-France 0.928
(0.585)
regionIle-de-France 5.003***
(0.521)
regionNormandie -0.030
(0.591)
regionNouvelle-Aquitaine 0.952**
(0.372)
regionOccitanie 0.591*
(0.357)
regionPays de la Loire -0.128
(0.622)
regionProvence-Alpes-Côte d’Azur 0.779
(0.534)
regionAuvergne-Rhône-Alpes:rea 0.903***
(0.015)
regionBourgogne-Franche-Comté:rea 0.850***
(0.054)
regionBretagne:rea 0.711***
(0.105)
regionCentre-Val de Loire:rea 0.467***
(0.073)
regionCorse:rea 0.826*
(0.494)
regionDOM-TOM:rea 0.579***
(0.094)
regionGrand Est:rea 0.890***
(0.048)
regionHauts-de-France:rea 0.817***
(0.017)
regionIle-de-France:rea 0.563***
(0.014)
regionNormandie:rea 1.134***
(0.058)
regionNouvelle-Aquitaine:rea 0.568***
(0.055)
regionOccitanie:rea 0.583***
(0.030)
regionPays de la Loire:rea 0.872***
(0.072)
regionProvence-Alpes-Côte d’Azur:rea 0.845***
(0.018)
Observations 2,626
R2 0.860
Adjusted R2 0.858
Residual Std. Error 6.103 (df = 2598)
F Statistic 568.970*** (df = 28; 2598)
Note: p<0.1; p<0.05; p<0.01

Test:

On teste le modèle sur les données de la semaine actuelle:

L’écart quadratique moyen est égal ici à :

## [1] 135.8053

7.2 Modèle 2 : série temporelle

On utilise la même stratégie que celle présentée pour prédire le nombre de nouveaux cas, de nouvelles hospitalisations et de nouvelles réanimations.

Etape d’apprentissage : on entraîne l’agorithme sur les données passées en enlevant la dernière semaine observée et on prédit sur cette semaine afin de calculer les écarts quadratiques avec les valeurs observées.

On représente le graphique des valeurs prédites / valeurs observées :

L’écart quadratique moyen est égal ici à :

## [1] 139.8950 119.6139 128.7129

Les 3 prédictions sont très proches et on va choisir un algorithme de type stepwise sur les prédictions pour choisir la meilleure combinaison et ne garder qu’une prédiction de type série temporelle:

## Start:  AIC=426.69
## my_basis[my_basis$semaine == "semaine_t00", "dc"] ~ pred_dc_2a + 
##     pred_dc_2b + pred_dc_2c - 1
## 
##              Df Sum of Sq    RSS    AIC
## <none>                    6505.4 426.69
## - pred_dc_2a  1    164.60 6670.1 427.22
## - pred_dc_2b  1    480.56 6986.0 431.89
## - pred_dc_2c  1   1275.89 7781.3 442.78
## [1] 64.41039

7.3 Combinaison des prédictions

Combinaison des prédictions: on peut envisager de faire un panaché des deux prédictions en régressant (avec un algorithme de type stepwise) le nombre de décés observé la semaine t0 en fonction des deux méthodes de régression. On obtient l’écart moyen quadratique suivant :

## [1] 58.76265

On adapte le poids des prédictions en fonction de la semaine à prédire

semaine_to_drop <- c("semaine_t0-4", "semaine_t0-3", "semaine_t0-2", "semaine_t0-1", "semaine_t00")
pred_dc_1_s2 <- numeric(0)
pred_dc_2a_s2 <- numeric(0)
pred_dc_2b_s2 <- numeric(0)
pred_dc_2c_s2 <- numeric(0)

y_true <- numeric(0)

for (j in 0:2) {
  
  semaine_to_estim <-  paste0("semaine_t0", j)
  y_true <- c(y_true, my_basis[my_basis$semaine == semaine_to_estim, "dc"])
  semaine_to_drop <- c(semaine_to_drop, paste0("semaine_t0", j + 1))
  res_lm_dc_1 <- lm(dc ~  region + rea:region - 1, 
             data = my_basis_dc[!(my_basis_dc$semaine %in% semaine_to_drop), ])
  pred_dc_1_s2 <- c(pred_dc_1_s2, 
     round(predict(res_lm_dc_1, newdata = my_basis_dc[my_basis_dc$semaine == semaine_to_estim, ])))
  pred_dc_2a_temp <- numeric(length(nom_dep))
  pred_dc_2b_temp <- numeric(length(nom_dep))
  pred_dc_2c_temp <- numeric(length(nom_dep))

  for (k in 1:length(nom_dep)) {
    temp <- hospital[!(hospital$semaine %in% semaine_to_drop) & 
                     hospital$dep == nom_dep[k], ]
    my_ts <- zoo(temp$incid_dc, temp$jour)
    my_ts_diff <- diff(my_ts)
    # tseries::adf.test(my_ts) 
    # tseries::adf.test(my_ts_diff)
    if (nom_dep[k] %in% c("975", "977", "978")) {
      pred_dc_2[k] <- NA
    } else {
      my_mod <- forecast::auto.arima(my_ts_diff)
      forecast_my_mod <- as.numeric(forecast(my_mod, h = 14)$mean)
      temp <- sum((as.numeric(my_ts[length(my_ts)]) + cumsum(forecast_my_mod))[1:7])
      pred_dc_2a_temp[k] <- sum((as.numeric(my_ts[length(my_ts)]) + cumsum(forecast_my_mod))[1:14]) - temp
      # modèles exponentiels
      # Méthode 2 : lissage exponentiel
      my_mod_exp <- ets(my_ts)
      forecast_my_mod_exp <- as.numeric(forecast(my_mod_exp, h = 14)$mean)
      forecast_my_mod_exp <- ifelse(forecast_my_mod_exp > 0, forecast_my_mod_exp, 0)
      temp <- round(sum(forecast_my_mod_exp[1:7]), 0)
      pred_dc_2b_temp[k] <- round(sum(forecast_my_mod_exp[1:14]), 0) - temp
      # Méthode 3 : lissage exponentiel sur données hebdomadaires
      temp <- my_basis[my_basis$dep == nom_dep[k] & !(my_basis$semaine %in% semaine_to_drop), ]
      my_ts_exp <- zoo(temp$dc, temp$jour)
      if (all(my_ts_exp == 0)) {
        pred_dc_2c_temp[k] <- 0
      } else {
        my_mod_exp_2 <- ets(my_ts_exp)
        forecast_my_mod_exp <- as.numeric(forecast(my_mod_exp_2)$mean)
        forecast_my_mod_exp <- ifelse(forecast_my_mod_exp > 0, forecast_my_mod_exp, 0)
        pred_dc_2c_temp[k] <- round(forecast_my_mod_exp[2], 0)
      }
    }
    
  }
   pred_dc_2a_s2 <- c(pred_dc_2a_s2, pred_dc_2a_temp)
   pred_dc_2b_s2 <- c(pred_dc_2b_s2, pred_dc_2b_temp)
   pred_dc_2c_s2 <- c(pred_dc_2c_s2, pred_dc_2c_temp)
}


lm_2_dc_ts_s1 <- step(lm(y_true ~ pred_dc_2a_s2 + pred_dc_2b_s2 + pred_dc_2c_s2 - 1))
## Start:  AIC=1574.89
## y_true ~ pred_dc_2a_s2 + pred_dc_2b_s2 + pred_dc_2c_s2 - 1
## 
##                 Df Sum of Sq   RSS    AIC
## <none>                       53722 1574.9
## - pred_dc_2b_s2  1     392.9 54115 1575.1
## - pred_dc_2c_s2  1    2177.0 55899 1584.9
## - pred_dc_2a_s2  1    3589.6 57312 1592.5
pred_dc_2_s2 <- predict(lm_2_dc_ts_s1)

lm_dc_3b <- lm(y_true ~ pred_dc_1_s2 + pred_dc_2_s2 - 1)

#######
# Semaine + 2
#######

semaine_to_drop <- c("semaine_t0-4", "semaine_t0-3", "semaine_t0-2", "semaine_t0-1", "semaine_t00", "semaine_t01")
pred_dc_1_s3 <- pred_dc_1_s2
pred_dc_2a_s3 <- pred_dc_2a_s2
pred_dc_2b_s3 <- pred_dc_2b_s2
pred_dc_2c_s3 <- pred_dc_2c_s2


for (j in 0:1) {
  
  semaine_to_estim <-  paste0("semaine_t0", j)
  y_true <- c(y_true, my_basis[my_basis$semaine == semaine_to_estim, "dc"])
  semaine_to_drop <- c(semaine_to_drop, paste0("semaine_t0", j + 2))
  
  res_lm_dc_1 <- lm(dc ~  region + rea:region - 1, 
             data = my_basis_dc[!(my_basis_dc$semaine %in% semaine_to_drop), ])
  pred_dc_1_s3 <- c(pred_dc_1_s3, round(predict(res_lm_dc_1, 
                      newdata = my_basis_dc[my_basis_dc$semaine == semaine_to_estim, ])))
  
  pred_dc_2a_temp <- numeric(length(nom_dep))
  pred_dc_2b_temp <- numeric(length(nom_dep))
  pred_dc_2c_temp <- numeric(length(nom_dep))

  for (k in 1:length(nom_dep)) {
     temp <- hospital[!(hospital$semaine %in% semaine_to_drop) & hospital$dep == nom_dep[k], ]
     my_ts <- zoo(temp$incid_dc, temp$jour)
     my_ts_diff <- diff(my_ts)
     # tseries::adf.test(my_ts) 
     # tseries::adf.test(my_ts_diff)
     if (nom_dep[k] %in% c("975", "977", "978")) {
       pred_dc_2[k] <- NA
     } else {
       my_mod <- forecast::auto.arima(my_ts_diff)
       forecast_my_mod <- as.numeric(forecast(my_mod, h = 21)$mean)
       temp1 <- sum((as.numeric(my_ts[length(my_ts)]) + cumsum(forecast_my_mod))[1:7])
       temp2 <- sum((as.numeric(my_ts[length(my_ts)]) + cumsum(forecast_my_mod))[1:14]) - temp1
       temp3 <- sum((as.numeric(my_ts[length(my_ts)]) + cumsum(forecast_my_mod))[1:21]) - temp1 - temp2
       pred_dc_2a_temp[k] <- ifelse(temp3 > 0, round(temp3), 0)
       # modèles exponentiels
       # Méthode 2 : lissage exponentiel
       my_mod_exp <- ets(my_ts)
       forecast_my_mod_exp <- as.numeric(forecast(my_mod_exp, h = 21)$mean)
       forecast_my_mod_exp <- ifelse(forecast_my_mod_exp > 0, forecast_my_mod_exp, 0)
       temp1 <- round(sum(forecast_my_mod_exp[1:7]), 0)
       temp2 <- round(sum(forecast_my_mod_exp[1:14]), 0) - temp1
       pred_dc_2b_temp[k] <- round(sum(forecast_my_mod_exp[1:21]), 0) - temp2 - temp1
       # Méthode 3 : lissage exponentiel sur données hebdomadaires
       temp <- my_basis[my_basis$dep == nom_dep[k] & !(my_basis$semaine %in% semaine_to_drop), ]
       my_ts_exp <- zoo(temp$dc, temp$jour)
       if (all(my_ts_exp == 0)) {
         pred_dc_2c_temp[k] <- 0
       } else {
         my_mod_exp_2 <- ets(my_ts_exp)
         forecast_my_mod_exp <- as.numeric(forecast(my_mod_exp_2)$mean)
         forecast_my_mod_exp <- ifelse(forecast_my_mod_exp > 0, forecast_my_mod_exp, 0)
         pred_dc_2c_temp[k] <- round(forecast_my_mod_exp[3], 0)
       }
    }
}

  pred_dc_2a_s3 <- c(pred_dc_2a_s3, pred_dc_2a_temp)
  pred_dc_2b_s3 <- c(pred_dc_2b_s3, pred_dc_2b_temp)
  pred_dc_2c_s3 <- c(pred_dc_2c_s3, pred_dc_2c_temp)
}

lm_2_dc_ts_s2 <- step(lm(y_true ~ pred_dc_2a_s3 + pred_dc_2b_s3 + pred_dc_2c_s3 - 1))
## Start:  AIC=2723.07
## y_true ~ pred_dc_2a_s3 + pred_dc_2b_s3 + pred_dc_2c_s3 - 1
## 
##                 Df Sum of Sq    RSS    AIC
## <none>                       109634 2723.1
## - pred_dc_2b_s3  1     709.8 110344 2724.3
## - pred_dc_2a_s3  1    6645.2 116279 2750.8
## - pred_dc_2c_s3  1    6681.7 116316 2750.9
pred_dc_2_s3 <- predict(lm_2_dc_ts_s2)

lm_dc_3c <- lm(y_true ~ pred_dc_1_s3 + pred_dc_2_s3 - 1)

#######
# Semaine T + 3
#######

semaine_to_drop <- c("semaine_t0-4", "semaine_t0-3", "semaine_t0-2", "semaine_t0-1", 
                     "semaine_t00", "semaine_t01", "semaine_t02")
pred_dc_1_s4 <- pred_dc_1_s3
pred_dc_2a_s4 <- pred_dc_2a_s3
pred_dc_2b_s4 <- pred_dc_2b_s3
pred_dc_2c_s4 <- pred_dc_2c_s3


for (j in 0:1) {
  
  semaine_to_estim <-  paste0("semaine_t0", j)
  y_true <- c(y_true, my_basis[my_basis$semaine == semaine_to_estim, "dc"])
  semaine_to_drop <- c(semaine_to_drop, paste0("semaine_t0", j + 3))
  
  res_lm_dc_1 <- lm(dc ~  region + rea:region - 1, 
             data = my_basis_dc[!(my_basis_dc$semaine %in% semaine_to_drop), ])
  pred_dc_1_s4 <- c(pred_dc_1_s4, round(predict(res_lm_dc_1, 
                      newdata = my_basis_dc[my_basis_dc$semaine == semaine_to_estim, ])))
  
  pred_dc_2a_temp <- numeric(length(nom_dep))
  pred_dc_2b_temp <- numeric(length(nom_dep))
  pred_dc_2c_temp <- numeric(length(nom_dep))

  for (k in 1:length(nom_dep)) {
     temp <- hospital[!(hospital$semaine %in% semaine_to_drop) & hospital$dep == nom_dep[k], ]
     my_ts <- zoo(temp$incid_dc, temp$jour)
     my_ts_diff <- diff(my_ts)
     # tseries::adf.test(my_ts) 
     # tseries::adf.test(my_ts_diff)
     if (nom_dep[k] %in% c("975", "977", "978")) {
       pred_dc_2[k] <- NA
     } else {
       my_mod <- forecast::auto.arima(my_ts_diff)
       forecast_my_mod <- as.numeric(forecast(my_mod, h = 28)$mean)
       temp1 <- sum((as.numeric(my_ts[length(my_ts)]) + cumsum(forecast_my_mod))[1:7])
       temp2 <- sum((as.numeric(my_ts[length(my_ts)]) + cumsum(forecast_my_mod))[1:14]) - temp1
       temp3 <- sum((as.numeric(my_ts[length(my_ts)]) + cumsum(forecast_my_mod))[1:21]) - temp1 - temp2 
       temp4 <- sum((as.numeric(my_ts[length(my_ts)]) + cumsum(forecast_my_mod))[1:28]) - temp1 - temp2 - temp3
       pred_dc_2a_temp[k] <- ifelse(temp4 > 0, round(temp4), 0)
       # modèles exponentiels
       # Méthode 2 : lissage exponentiel
       my_mod_exp <- ets(my_ts)
       forecast_my_mod_exp <- as.numeric(forecast(my_mod_exp, h = 28)$mean)
       forecast_my_mod_exp <- ifelse(forecast_my_mod_exp > 0, forecast_my_mod_exp, 0)
       temp1 <- round(sum(forecast_my_mod_exp[1:7]), 0)
       temp2 <- round(sum(forecast_my_mod_exp[1:14]), 0) - temp1
       temp3 <- round(sum(forecast_my_mod_exp[1:21]), 0) - temp1 - temp2
       pred_dc_2b_temp[k] <- round(sum(forecast_my_mod_exp[1:28]), 0) - temp1 - temp2 - temp3
       # Méthode 3 : lissage exponentiel sur données hebdomadaires
       temp <- my_basis[my_basis$dep == nom_dep[k] & !(my_basis$semaine %in% semaine_to_drop), ]
       my_ts_exp <- zoo(temp$dc, temp$jour)
       if (all(my_ts_exp == 0)) {
         pred_dc_2c_temp[k] <- 0
       } else {
         my_mod_exp_2 <- ets(my_ts_exp)
         forecast_my_mod_exp <- as.numeric(forecast(my_mod_exp_2)$mean)
         forecast_my_mod_exp <- ifelse(forecast_my_mod_exp > 0, forecast_my_mod_exp, 0)
         pred_dc_2c_temp[k] <- round(forecast_my_mod_exp[4], 0)
       }
    }
}

  pred_dc_2a_s4 <- c(pred_dc_2a_s4, pred_dc_2a_temp)
  pred_dc_2b_s4 <- c(pred_dc_2b_s4, pred_dc_2b_temp)
  pred_dc_2c_s4 <- c(pred_dc_2c_s4, pred_dc_2c_temp)
}

lm_2_dc_ts_s3 <- step(lm(y_true ~ pred_dc_2a_s4 + pred_dc_2b_s4 + pred_dc_2c_s4 - 1))
## Start:  AIC=4073.93
## y_true ~ pred_dc_2a_s4 + pred_dc_2b_s4 + pred_dc_2c_s4 - 1
## 
##                 Df Sum of Sq    RSS    AIC
## <none>                       222977 4073.9
## - pred_dc_2b_s4  1    1430.7 224408 4076.5
## - pred_dc_2a_s4  1    7012.9 229990 4093.8
## - pred_dc_2c_s4  1   13524.9 236502 4113.6

7.4 Prédiction

On prédit:

  • le nombre de décès à venir du [01 décembre 2020; 07 décembre 2020] en utilisant les nouvelles réanimations du [24 novembre 2020; 30 novembre 2020]

  • le nombre de décès à venir du [08 décembre 2020; 14 décembre 2020] en utilisant la prédiction des réanimations à venir du [01 décembre 2020; 07 décembre 2020]

  • le nombre de décès à venir du [15 décembre 2020; 21 décembre 2020] en utilisant la prédiction des réanimations à venir du [08 décembre 2020; 14 décembre 2020]

  • le nombre de décès à venir du [22 décembre 2020; 28 décembre 2020] en utilisant la prédiction des réanimations à venir du [08 décembre 2020; 14 décembre 2020]

Pour cela, on actualise le modèle, c’est-à-dire qu’on inclut la dernière semaine observée:

res_lm <- lm(dc ~  region + rea:region - 1, 
             data = my_basis_dc[!(my_basis_dc$semaine %in% c("semaine_t0-2", "semaine_t0-1")), ])

# semaine t+1
new_data_dc_1 <- my_basis_dc[my_basis_dc$semaine %in% c("semaine_t0-1", "semaine_t0-2", "semaine_t0-3", "semaine_t0-4"),  ]
pred_dc_1 <- predict(res_lm, newdata = new_data_dc_1)

pred_dc_2 <- matrix(0, length(nom_dep), 4)
pred_dc_2a <- matrix(0, length(nom_dep), 4)
pred_dc_2b <- matrix(0, length(nom_dep), 4)
pred_dc_2c <- matrix(0, length(nom_dep), 4)
for (k in 1:length(nom_dep)) {
  temp <- hospital[!(hospital$semaine %in% c("semaine_t0-4", "semaine_t0-3", "semaine_t0-2", "semaine_t0-1")) & 
                     hospital$dep == nom_dep[k], ]
  my_ts <- zoo(temp$incid_dc, temp$jour)
  my_ts_diff <- diff(my_ts)
  # tseries::adf.test(my_ts) 
  # tseries::adf.test(my_ts_diff)
  if (nom_dep[k] %in% c("975", "977", "978")) {
    pred_rea_2[k] <- NA
  } else {
    my_mod <- forecast::auto.arima(my_ts_diff)
    forecast_my_mod <- as.numeric(forecast(my_mod, h = 28)$mean)
    pred_3a_s1 <- sum((as.numeric(my_ts[length(my_ts)]) + cumsum(forecast_my_mod))[1:7])
    pred_3a_s2 <- sum((as.numeric(my_ts[length(my_ts)]) + cumsum(forecast_my_mod))[1:14]) - pred_3a_s1
    pred_3a_s3 <- sum((as.numeric(my_ts[length(my_ts)]) + cumsum(forecast_my_mod))[1:21]) - 
      pred_3a_s1 - pred_3a_s2
    pred_3a_s4 <- sum((as.numeric(my_ts[length(my_ts)]) + cumsum(forecast_my_mod))[1:28]) - 
      pred_3a_s1 - pred_3a_s2 - pred_3a_s3
        # Lissage exponentiel
    my_mod_exp <- ets(my_ts)
    forecast_my_mod_exp <- as.numeric(forecast(my_mod_exp, h = 28)$mean)
    forecast_my_mod_exp <- ifelse(forecast_my_mod_exp > 0, forecast_my_mod_exp, 0)
    pred_3b_s1 <- round(sum(forecast_my_mod_exp[1:7]), 0)
    pred_3b_s2 <- round(sum(forecast_my_mod_exp[1:14]), 0) - pred_3b_s1
    pred_3b_s3 <- round(sum(forecast_my_mod_exp[1:21]), 0) - pred_3b_s2 - pred_3b_s1
    pred_3b_s4 <- round(sum(forecast_my_mod_exp[1:28]), 0) - pred_3b_s3 - pred_3b_s2 - pred_3b_s1
    # Méthode 3 : lissage exponentiel sur données hebdomadaires
    temp <- my_basis[my_basis$dep == nom_dep[k] & !(my_basis$semaine %in% 
                                          c("semaine_t0-4", "semaine_t0-3", "semaine_t0-2", "semaine_t0-1")), ]
    my_ts_exp <- zoo(temp$dc, temp$jour)
    my_mod_exp_2 <- ets(my_ts_exp)
    forecast_my_mod_exp <- as.numeric(forecast(my_mod_exp_2)$mean)
    forecast_my_mod_exp <- ifelse(forecast_my_mod_exp > 0, forecast_my_mod_exp, 0)
    pred_3c_s1 <- round(forecast_my_mod_exp[1], 0)
    pred_3c_s2 <- round(forecast_my_mod_exp[2], 0)
    pred_3c_s3 <- round(forecast_my_mod_exp[3], 0)    
    pred_3c_s4 <- round(forecast_my_mod_exp[4], 0) 
      
    pred_dc_2[k, 1] <- predict(lm_2_dc_ts, newdata = data.frame(pred_dc_2a = pred_3a_s1,
                                                 pred_dc_2b = pred_3b_s1,
                                                 pred_dc_2c = pred_3c_s1))
    pred_dc_2[k, 2] <- predict(lm_2_dc_ts_s1, newdata = data.frame(pred_dc_2a_s2 = pred_3a_s2,
                                                 pred_dc_2b_s2 = pred_3b_s2,
                                                 pred_dc_2c_s2 = pred_3c_s2))
    pred_dc_2[k, 3] <- predict(lm_2_dc_ts_s2, newdata = data.frame(pred_dc_2a_s3 = pred_3a_s3,
                                                 pred_dc_2b_s3 = pred_3b_s3,
                                                 pred_dc_2c_s3 = pred_3c_s3))
    pred_dc_2[k, 4] <- predict(lm_2_dc_ts_s3, newdata = data.frame(pred_dc_2a_s4 = pred_3a_s4,
                                                 pred_dc_2b_s4 = pred_3b_s4,
                                                 pred_dc_2c_s4 = pred_3c_s4))  
  }
}

n_4 <- 4 * length(nom_dep) 

pred_dc_a <- predict(lm_dc_3, newdata = data.frame(pred_dc_1 = 
                        pred_dc_1[new_data_dc_1$semaine == "semaine_t0-1"],
                        pred_dc_2 = as.vector(pred_dc_2)[1:(n_4 / 4)]))

pred_dc_b <- predict(lm_dc_3b, newdata = data.frame(
  pred_dc_1_s2 = pred_dc_1[new_data_dc_1$semaine == "semaine_t0-2"],
  pred_dc_2_s2 = as.vector(pred_dc_2)[((n_4 / 4) + 1):(2 * n_4 / 4)]))

pred_dc_c <- predict(lm_dc_3c, newdata = data.frame(
  pred_dc_1_s3 = pred_dc_1[new_data_dc_1$semaine == "semaine_t0-3"],
  pred_dc_2_s3 = as.vector(pred_dc_2)[(2 * n_4 / 4 + 1):(3 * n_4 / 4)]))

pred_dc_d <- predict(lm_dc_4c, newdata = data.frame(
  pred_dc_1_s4 = pred_dc_1[new_data_dc_1$semaine == "semaine_t0-4"],
  pred_dc_2_s4 = as.vector(pred_dc_2)[(3 * n_4 / 4 + 1):n_4]))



# on synthétise les résultats
new_data <- my_basis[my_basis$semaine %in% "semaine_t0-1", ]
new_data$this_week <- my_basis_dc[my_basis_dc$semaine == "semaine_t00", "dc"]
new_data$next_week <- pred_dc_a
new_data$next_two_week <- pred_dc_b
new_data$next_three_week <- pred_dc_c
new_data$next_four_week <- pred_dc_d
my_basis[my_basis$semaine %in% "semaine_t0-1", "dc"] <- pred_dc_a
my_basis[my_basis$semaine %in% "semaine_t0-2", "dc"] <- pred_dc_b
my_basis[my_basis$semaine %in% "semaine_t0-3", "dc"] <- pred_dc_c
my_basis[my_basis$semaine %in% "semaine_t0-4", "dc"] <- pred_dc_d

On va représenter l’évolution du nombre de décès dans un intervalle de temps de 5 semaines :

  • les 7 derniers jours passés : [24 novembre 2020; 30 novembre 2020]
  • la semaine à venir : [01 décembre 2020; 07 décembre 2020]
  • la 2ème semaine à venir : [08 décembre 2020; 14 décembre 2020]
  • la 3ème semaine à venir : [15 décembre 2020; 21 décembre 2020]
  • la 4ème semaine à venir : [15 décembre 2020; 21 décembre 2020]

On aggrège les données à la France entière:

Soit un nombre de décès par jour de :

## # A tibble: 5 x 2
##   semaine               dc
##   <fct>              <dbl>
## 1 [24 nov.; 30 nov.]  342.
## 2 [01 déc.; 07 déc.]  264.
## 3 [08 déc.; 14 déc.]  207.
## 4 [15 déc.; 21 déc.]  169.
## 5 [22 déc.; 28 déc.]  132.