README.Rmd

---
output:
  md_document:
    variant: markdown_github
---

<!-- README.md is generated from README.Rmd. Please edit that file -->

[![Build Status](https://travis-ci.org/rte-antares-rpackage/antaDraft.svg?branch=master)](https://travis-ci.org/rte-antares-rpackage/antaDraft) 
[![AppVeyor Build Status](https://ci.appveyor.com/api/projects/status/github/rte-antares-rpackage/antaDraft?branch=master&svg=true)](https://ci.appveyor.com/project/rte-antares-rpackage/antaDraft) 
[![version](http://www.r-pkg.org/badges/version/antaDraft)](https://CRAN.R-project.org/package=antaDraft) 
[![Project Status: WIP - Initial development is in progress, but there has not yet been a stable, usable release suitable for the public.](http://www.repostatus.org/badges/latest/wip.svg)](http://www.repostatus.org/#wip) 
[![codecov](https://codecov.io/gh/rte-antares-rpackage/antaDraft/branch/master/graph/badge.svg)](https://codecov.io/gh/rte-antares-rpackage/antaDraft)

```{r, echo = FALSE}
library(knitr)
knitr::opts_chunk$set(
  echo = TRUE,
  collapse = TRUE,
  comment = "#>",
  fig.path = "tools/README/",
  message = FALSE,
  warning = FALSE
)
```

# antaDraft

Le package contient un ensemble de fonctions pour vérifier et corriger des données entsoe.

L'objectif du package est de permettre la création d'un jeu de données complet pour deux années de données et pour plusieurs pays. 

Les données peuvent être manquantes ou imparfaites. Il s'agit de permettre :

* l'identification des problèmes, 
* leur reporting afin de permettre leur correction par l'entsoe, 
* leur correction si la donnée n'a pu être corrigée par l'entsoe. 

La procédure est pour l'instant implémentée pour les données de consommation.


## Utilisation

On va charger l'ensemble des données archivées sur archive.org à l'URL suivante : https://archive.org/details/RTE_load

Le zip à charger est le suivant: https://archive.org/download/RTE_load/load.zip.

```{r}
load_dir <- file.path(tempdir(), "load_files" )
load_zip <- file.path(tempdir(), "load.zip" )

local_zip <- "/Users/davidgohel/Documents/consulting/RTE/load_20180115.zip"
if( file.exists(local_zip))
  file.copy(local_zip, load_zip, overwrite = TRUE )

if( !file.exists(load_zip) )
  download.file(url = "https://archive.org/download/RTE_load/load.zip", 
                destfile = load_zip )

if( dir.exists(load_dir) )
  unlink(load_dir, recursive = TRUE, force = TRUE)

utils::unzip(load_zip, exdir = load_dir )
```

Les données sont disponibles dans le répertoire `r load_dir`. Celui ci contient les fichiers suivants :

```{r}
csv_files <- list.files(load_dir, full.names = TRUE, pattern = "\\.csv$")
csv_infos <- file.info(csv_files)[, c(1, 3) ]
row.names(csv_infos) <- NULL
csv_infos$file <- basename(csv_files)

kable(csv_infos)
```


### Les données brutes

Avant de dégager une série de consommation par pays

```{r}
library(antaDraft)
load_data <- anta_load(data_dir = load_dir )
```

### Validation des données brutes

L'opération va ajouter autant de colonnes qu'il y a 
de tests exprimés dans le fichier `config/load/raw_validate.yml`.

Ce fichier décrit les règles de validation de chaque ligne de donnée.

```{r echo=FALSE}
raw_validate <- system.file(package = "antaDraft", "config", "load", "raw_validate.yml")
raw_validate <- paste0(readLines(raw_validate), collapse = "\n" )
htmltools::tags$pre(raw_validate)
```


```{r}
load_data <- augment_validation(load_data)
head(load_data)
```


### Les données agrégées

On va produire les données agrégées avec la fonction 
`aggregate_with_rules`. Les règles sont 
exprimées dans le fichier `config/global/atc_per_country.yml`.

```{r echo=FALSE}
atc_per_country <- system.file(package = "antaDraft", "config", "global", "atc_per_country.yml")
atc_per_country <- paste0(readLines(atc_per_country), collapse = "\n" )
htmltools::tags$pre(atc_per_country)
```

La fonction prend des données de *load* comme argument, c'est à dire obtenue avec la fonction `anta_load()`.

```{r}
aggregated_db <- agg_data(load_data)
```

Ces données peuvent être représentées graphiquement avec la 
fonction `plot` (voire `?plot_agg`).

```{r}
plot_agg(aggregated_db, subset = aggregated_db$country %in% "SWITZERLAND")
```


### Validation des données agrégées

Comme pour les données brutes, l'opération va ajouter autant de colonnes qu'il y a de tests exprimés dans le fichier `agg_validate.yml`.

```{r echo=FALSE}
raw_validate <- system.file(package = "antaDraft", "config", "load", "agg_validate.yml")
raw_validate <- paste0(readLines(raw_validate), collapse = "\n" )
htmltools::tags$pre(raw_validate)
```


```{r}
aggregated_db <- augment_validation(aggregated_db)
```

Ces données peuvent être représentées graphiquement avec la 
fonction `plot` (voire `?plot.controled`).

```{r}
plot(aggregated_db, subset = aggregated_db$country %in% "SWITZERLAND")
```


### Correction mécanique des données agrégées

```{r}
aggregated_db <- data_correct_with_rules(aggregated_db)
```

### Qualification résumée des lignes agrégées

```{r}
aggregated_db <- augment_process_summary(aggregated_db)

library(dplyr)
library(tidyr)
aggregated_db %>% 
  group_by_at(c( "country", "summary") ) %>% 
  tally() %>% 
  spread(summary, n) %>% 
  kable()
```

## Correction des données par modèles de prévisions

Il faut dans un premier temps enrichir la base de données avec des 
variables potentiellement explicatives. On utilise la fonction `as_learning_db`.

```{r}
dat <- as_learning_db(aggregated_db )
head(dat)
```

On peut alors créer deux modèles, un dépandant des mesures suivantes et un dépendant 
des mesures précédentes.

On utilisera pour cela la fonction `define_model_rf`. Celle-ci sauvegarde les modèles dans un répertoire 
local à la machine.

```{r eval=FALSE}
repertoire_model <- tempfile()
dir.create(repertoire_model, showWarnings = FALSE, recursive = TRUE)
```

Création du modèle *backward*:

```{r eval=FALSE}
x_vars <- c(
  "year.iso", "week.iso", "hour.iso", "day.iso", "light_time",
  "is_off", "likely_off",
  "DAILY_MIN_CTY_MINUS_1", "DAILY_AVG_CTY_MINUS_1", "DAILY_MAX_CTY_MINUS_1",
  "HOUR_SHIFT_CTY_MINUS_1")

dat <- define_model_rf( 
  data = dat, x_vars = x_vars, y_var = "CTY",
  save_model_dir = repertoire_model, id = "BACKWARD" )
```

Création du modèle *forward*:

```{r eval=FALSE}
x_vars <- c(
  "year.iso", "week.iso", "hour.iso", "day.iso", "light_time",
  "is_off", "likely_off",
  "DAILY_MIN_CTY_PLUS_1", "DAILY_AVG_CTY_PLUS_1", "DAILY_MAX_CTY_PLUS_1",
  "HOUR_SHIFT_CTY_PLUS_1")

dat <- define_model_rf( 
  data = dat, x_vars = x_vars, y_var = "CTY",
  save_model_dir = repertoire_model, id = "FORWARD" )
```

Maintenant qu'on a deux modèles, on peut les utiliser en boucle pour 
remplacer les valeurs invalides par des valeurs prévues par les modèles.

```{r eval=FALSE}
for(i in 1:12 ){
  dat <- impute_with_model(dat, id = "FORWARD")
  dat <- impute_with_model(dat, id = "BACKWARD")
  dat <- update_learning_db(dat)
}
```


```{r eval=FALSE}
library(dplyr)
library(tidyr)
dat %>% 
  group_by_at(c( "country", "summary") ) %>% 
  tally() %>% 
  spread(summary, n) %>% 
  kable()
```

```{r echo=FALSE, eval=FALSE}
unlink(repertoire_model, recursive = TRUE, force = TRUE)
```