Tau-Argus depuis R - données tabulées • rtauargus

library(dplyr)

Introduction

Présentation du package

Le package rtauargus offre une interface R pour τ-Argus. Il permet de :

créer des input (fichiers asc, tab et rda) à partir de données R ;
de générer la séquence d’instructions à exécuter en mode batch (fichier arb) ;
lancer un batch τ-Argus ;
récupérer les résultats dans R.

La syntaxe de certains des arguments correspond étroitement à la syntaxe batch de τ-Argus. Cela permet d’utiliser un nombre important de fonctions sans multiplier les arguments des fonctions. Le package pourra également s’adapter plus facilement aux éventuelles modifications du logiciel (nouveaux algorithmes disponibles, options supplémentaires…). Les règles de syntaxes d’écriture du batch sont détaillés dans le manuel de référence de τ-Argus et sont égalements précisées dans la vignette options_safety_rules.

Le package a été développé sur la base de versions open source de τ-Argus (versions 4.2 et supérieures), en particulier la dernière version disponible au moment du développement (4.2.3).

Il n’est pas compatible avec la version 3.5.**_.

But de ce document

Ce document a pour but d’expliquer les principales fonctionnalités du package, en utilisant des exemples relativement simples. Une documentation détaillée de toute fonction (liste exhaustive des arguments, aspects techniques…) est disponible via la section d’aide dédiée.

summary ↑

Configuration

Le paramétrage suivant doit être fait avant la première utilisation (et plus après).

τ-Argus

rtauargus fonctions utilisant τ-Argus nécessite que le logiciel puisse être utilisé depuis le poste de travail. Le dépôt github de τ-Argus est ici : https://github.com/sdcTools/tauargus. Les dernières versions peuvent être téléchargées ici : https://github.com/sdcTools/tauargus/releases.

Dépendances

rtauargus nécessite quelques autres packages R. Voici les dépendances à installer.

• purrr (>= 0.2),
• dplyr (>= 0.7),
• gdata,
• stringr,
• rlang,
• zoo,
• sdcHierarchies

Le package rtauargus peut être installé maintenant.

summary ↑

Prise en main

Cette section explique comment effectuer une configuration minimale du package et comment appliquer des méthodes de suppression en une seule instruction.

Location de τ-Argus

Lors du chargement du package, la console affiche quelques informations :

library(rtauargus)

En particulier, un emplacement plausible pour le logiciel τ-Argus est prédéfini. Celui-ci peut être modifié pour la durée de la session R, comme suit :

loc_tauargus <- "Y:/Logiciels/TauArgus/TauArgus4.2.3/TauArgus.exe"

options(rtauargus.tauargus_exe = loc_tauargus)

Une fois ce petit ajustement effectué, le package est prêt à être utilisé.

Pour une configuration plus personnalisée, voir les vignettes spécifiques.

Protéger un seul tableau avec la fonction `tab_rtauargus()`.

La fonction tab_rtauargus() effectue un traitement complet pour protéger le tableau et récupère immédiatement les résultats dans R.

En s’abstrayant complètement du fonctionnement interne de τ-Argus, elle permet de réaliser l’ensemble des traitements en une seule instruction. Tous les fichiers intermédiaires sont créés dans un répertoire local.

tab_rtauargus() requiert les arguments suivants :

tabular : un data.frame contenant le tableau ;
dir_name : le répertoire pour les sorties ;
files_name : tous les fichiers τ-Argus seront nommés ainsi(différentes extensions) ;
explanatory_vars : le nom de toutes les variables explicatives dans tabular ;
secret_var ou safety_rules : la manière d’appliquer la suppression primaire (expliqué plus tard)
totcode : le code pour le total de chaque variable explicative dans tabular.

Tous les arguments et leurs options par défaut seront détaillés ( où ?).

Exemple minimal

Pour la présentation un tableau fictif sera utilisé :

act_size <-
  data.frame(
    ACTIVITY = c("01","01","01","02","02","02","06","06","06","Total","Total","Total"),
    SIZE = c("tr1","tr2","Total","tr1","tr2","Total","tr1","tr2","Total","tr1","tr2","Total"),
    VAL = c(100,50,150,30,20,50,60,40,100,190,110,300),
    N_OBS = c(10,5,15,2,5,7,8,6,14,20,16,36),
    MAX = c(20,15,20,20,10,20,16,38,38,20,38,38)
  )
act_size
#>    ACTIVITY  SIZE VAL N_OBS MAX
#> 1        01   tr1 100    10  20
#> 2        01   tr2  50     5  15
#> 3        01 Total 150    15  20
#> 4        02   tr1  30     2  20
#> 5        02   tr2  20     5  10
#> 6        02 Total  50     7  20
#> 7        06   tr1  60     8  16
#> 8        06   tr2  40     6  38
#> 9        06 Total 100    14  38
#> 10    Total   tr1 190    20  20
#> 11    Total   tr2 110    16  38
#> 12    Total Total 300    36  38

Nous utiliserons ces deux règles de secret primaire :

La règle de dominance n-k avec n=1 et k = 85.
La règle de fréquence minimale avec n = 3 et un intervalle de protection à 10%.

Pour obtenir les résultats de la règle de dominance, nous devons spécifier le plus grand contributeur de chaque cellule, correspondant à la variable MAX dans les données tabulées.

ex1 <- tab_rtauargus(
  act_size,
  dir_name = "tauargus_files/ex1",
  files_name = "ex1",
  explanatory_vars = c("ACTIVITY","SIZE"),
  safety_rules = "FREQ(3,10)|NK(1,85)",
  value = "VAL",
  freq = "N_OBS",
  maxscore = "MAX",
  totcode = c(ACTIVITY="Total",SIZE="Total")
)
#> Start of batch procedure; file: Z:\SDC\OutilsConfidentialite\rtauargus\vignettes\tauargus_files\ex1\ex1.arb
#> <OPENTABLEDATA> "Z:\SDC\OutilsConfidentialite\rtauargus\vignettes\tauargus_files\ex1\ex1.tab"
#> <OPENMETADATA> "Z:\SDC\OutilsConfidentialite\rtauargus\vignettes\tauargus_files\ex1\ex1.rda"
#> <SPECIFYTABLE> "ACTIVITY""SIZE"|"VAL"||
#> <SAFETYRULE> FREQ(3,10)|NK(1,85)
#> <READTABLE> 1
#> Tables have been read
#> <SUPPRESS> MOD(1,5,1,0,0)
#> Start of the modular protection for table ACTIVITY x SIZE | VAL
#> End of modular protection. Time used 0 seconds
#>                    Number of suppressions: 2
#> <WRITETABLE> (1,4,,"Z:\SDC\OutilsConfidentialite\rtauargus\vignettes\tauargus_files\ex1\ex1.csv")
#> Table: ACTIVITY x SIZE | VAL has been written
#>                    Output file name: Z:\SDC\OutilsConfidentialite\rtauargus\vignettes\tauargus_files\ex1\ex1.csv
#> End of TauArgus run

Par défaut, la fonction affiche dans la console le contenu du journal de bord dans lequel l’utilisateur peut lire toutes les étapes exécutées par τ-Argus. Ceci peut être récupéré dans le fichier logbook.txt. Avec verbose = FALSE, les étapes seront seulement conservées dans le journal.

Par défaut, la fonction renvoie le tableau fournit en entrée avec une variable de plus appelée Status, issue directement de τ-Argus et décrivant le statut de chaque cellule comme suit :

-A : cellule en secret primaire en raison de la règle de fréquence ; -B : cellule en secret primaire en raison de la règle de dominance (1er contributeur) ; -C : cellule en secret primaire en raison de la règle de dominance(plus de contributeurs dans le cas où n>1) ; -D : cellule en secret secondaire ; -V : cellules valides - pas besoin de masquer.

ex1
#>    ACTIVITY  SIZE VAL N_OBS MAX Status
#> 1        01 Total 150    15  20      V
#> 2        01   tr1 100    10  20      V
#> 3        01   tr2  50     5  15      V
#> 4        02 Total  50     7  20      V
#> 5        02   tr1  30     2  20      A
#> 6        02   tr2  20     5  10      D
#> 7        06 Total 100    14  38      V
#> 8        06   tr1  60     8  16      D
#> 9        06   tr2  40     6  38      B
#> 10    Total Total 300    36  38      V
#> 11    Total   tr1 190    20  20      V
#> 12    Total   tr2 110    16  38      V

Tous les fichiers générés par la fonction sont écrits dans le répertoire spécifié (argument dir_name). Le format par défaut du tableau protégé est csv mais il peut être modifié. Tous les fichiers τ-Argus (.tab, .rda, .arb et .txt) sont écrits dans le même répertoire. Pour aller plus loin, vous pouvez consulter la dernière version du manuel de τ-Argus téléchargeable ici : https://research.cbs.nl/casc/Software/TauManualV4.1.pdf.

Exemple avec une hiérarchie et pose du secret primaire via R

Données

Dans cet exemple, nous souhaitons protéger un tableau dans lequel le chiffre d’affaires des entreprises est ventilé par secteur d’activité et par taille. Pour charger les données :

data("turnover_act_size")
head(turnover_act_size)
#> # A tibble: 6 x 5
#>   ACTIVITY SIZE  N_OBS       TOT       MAX
#>   <chr>    <chr> <int>     <dbl>     <dbl>
#> 1 AZ       Total   405    44475.     6212.
#> 2 BE       Total 12878 24827613.  1442029.
#> 3 FZ       Total 28043  8907311.  1065833.
#> 4 GI       Total 62053 26962063.  3084242.
#> 5 JZ       Total  8135  8584917.  3957364.
#> 6 KZ       Total  8140 62556596. 10018017.

La signification de chaque variable est la suivante :

-ACTIVITY : secteur d’activité, variables hiérarchiques à trois niveaux décrites dans l’ensemble de données activity_corr_table. La racine est notée “Total” ; -SIZE : taille des entreprises (Nombre d’employés dans trois modalités + la marge “Total”) ; -N_OBS : Fréquence, nombre d’entreprises ; -TOT : valeur du chiffre d’affaires en euros ; -MAX : chiffre d’affaires de l’entreprise qui contribue le plus à la cellule.

Fichier hiérarchique

Avant d’exécuter la fonction tab_rtauargus(), nous devons renseigner les imbrications de la hiérarchie dans le format approprié pour τ-Argus, .i.e. un fichier .hrc. A partir d’un tableau de correspondance, la fonction write_hrc2() fait le travail pour vous.

Ici, le tableau de correspondance décrit l’imbrication des trois niveaux de secteurs d’activité, du plus agrégé au moins agrégé :

data(activity_corr_table)
head(activity_corr_table)
#>   A10 A21 A88
#> 1  AZ   A  01
#> 2  AZ   A  02
#> 3  AZ   X   X
#> 4  BE   B  06
#> 5  BE   B  07
#> 6  BE   B  08

hrc_file_activity <- write_hrc2(
  corr_table = activity_corr_table,
  file_name = "hrc/activity.hrc"
)

Secret primaire

Dans cet exemple, nous appliquerons nous-mêmes le secret primaire, c’est-à-dire sans l’aide de τ-Argus. L’idée est d’utiliser τ-Argus avec un fichier apriori (.hst). Qui permet de spécifier directement au logiciel quelles cellules sont à placer en secret primaire. Pour cela, nous créons une variable booléenne pour spécifier quelles cellules ne respectent pas les règles du secret primaire. En utilisant les mêmes règles que précédemment, on obtient :

turnover_act_size <- turnover_act_size %>%
  mutate(
    is_secret_freq = N_OBS > 0 & N_OBS < 3,
    is_secret_dom = MAX > TOT*0.85,
    is_secret_prim = is_secret_freq | is_secret_dom
  )

Exécution de τ-Argus

Deux arguments doivent être ajoutés à la fonction tab_rtauargus() :

-secret_var, indiquant le nom de la variable dans tabular qui renseigne le secret primaire ; -hrc, indiquant le nom du fichier hiérarchique à utiliser pour la variable ACTIVITY.

Puisque le secret primaire a été spécifié, il n’est pas nécessaire d’utiliser les arguments, safety_rules et maxscore. Le premier est fixé par défaut à “MAN(10)”, afin d’appliquer un intervalle de protection à 10%.

Par défaut, tab_rtauargus() exécute la méthode Modular pour effectuer le secret secondaire. Ici, nous choisissons d’utiliser la méthode Optimal en modifiant l’argument suppress.

ex2 <- tab_rtauargus(
  turnover_act_size,
  dir_name = "tauargus_files/ex2",
  files_name = "ex2",
  explanatory_vars = c("ACTIVITY","SIZE"),
  value = "TOT",
  freq = "N_OBS",
  secret_var = "is_secret_prim",
  hrc = c(ACTIVITY = hrc_file_activity),
  totcode = c(ACTIVITY="Total",SIZE="Total"),
  suppress = "OPT(1,5)",
  verbose=FALSE
)

Résultat

str(ex2)
#> 'data.frame':    414 obs. of  9 variables:
#>  $ ACTIVITY      : chr  "01" "01" "02" "02" ...
#>  $ SIZE          : chr  "Total" "tr1" "Total" "tr1" ...
#>  $ N_OBS         : int  18 18 387 381 6 1 1 4 4 84 ...
#>  $ TOT           : num  853 853 43623 35503 8120 ...
#>  $ MAX           : num  303 303 6212 6212 4812 ...
#>  $ is_secret_freq: logi  FALSE FALSE FALSE FALSE FALSE TRUE ...
#>  $ is_secret_dom : logi  FALSE FALSE FALSE FALSE FALSE TRUE ...
#>  $ is_secret_prim: logi  FALSE FALSE FALSE FALSE FALSE TRUE ...
#>  $ Status        : chr  "V" "V" "V" "V" ...

table(ex2$Status)
#> 
#>   B   D   V 
#>  77  64 273

Comme on peut le voir dans les résultats du table(),dans la sortie produite par τ-Argus tous les secrets primaires ont le statut “B”. Pour corriger cela, nous pouvons faire :

ex2 %>%
  mutate(
    Status = dplyr::case_when(
      is_secret_freq ~ "A",
      TRUE ~ Status
    )
  ) %>%
  dplyr::count(Status)
#>   Status   n
#> 1      A  52
#> 2      B  25
#> 3      D  64
#> 4      V 273

Protéger plusieurs tableaux en même temps, avec la fonction `tab_muli_manager()`.

La fonction tab_multi_manager() permet de traiter un ensemble de tableaux (liés ou non). C’est un processus itératif, qui effectue la pose de secret secondaire d’un tableau à la fois et qui s’assure que les cellules communes ont le même statut. Lorsqu’une cellule commune est concernée par le secret secondaire, elle répercute le secret sur chaque tableau qui partage cette cellule commune. Le processus se termine lorsque le secret secondaire est cohérent pour tous les tableaux. Voir plus de détails dans les vignettes Gérer la protection des tableaux liés.

Données

Pour cet exemple, deux tableaux seront utilisés :

data("turnover_act_size")
data("turnover_act_cj")
str(turnover_act_cj)
#> tibble [406 x 5] (S3: tbl_df/tbl/data.frame)
#>  $ ACTIVITY: chr [1:406] "AZ" "BE" "FZ" "GI" ...
#>  $ CJ      : chr [1:406] "Total" "Total" "Total" "Total" ...
#>  $ N_OBS   : int [1:406] 405 12878 28043 62053 8135 8140 11961 41359 26686 25108 ...
#>  $ TOT     : num [1:406] 44475 24827613 8907311 26962063 8584917 ...
#>  $ MAX     : num [1:406] 6212 1442029 1065833 3084242 3957364 ...

Le deuxième tableau fournit le chiffre d’affaires des entreprises ventilé par secteurs d’activité (ACTIVITY) et par type d’entreprise (CJ).

Les deux tableaux ayant une variable explicative commune (ACTIVITY), ils ne peuvent être traités séparément sans générer risque de rupture du secret secondaire.

Secret primaire

La première étape consiste à indiquer si chaque cellule respecte les règles primaires, ou non. Une variable booléenne est créée, égale à TRUE si la cellule n’est pas conforme.

Ici, on utilise les mêmes règles que précédemment.

list_data_2_tabs <- list(
  act_size = turnover_act_size,
  act_cj = turnover_act_cj
) %>%
  purrr::map(
    function(df){
      df %>%
        mutate(
          is_secret_freq = N_OBS > 0 & N_OBS < 3,
          is_secret_dom = MAX > TOT*0.85,
          is_secret_prim = is_secret_freq | is_secret_dom
        )
    }
  )

Exécution de τ-Argus

Maintenant que le secret primaire a été spécifié pour les deux tableaux, nous pouvons lancer le processus.

ex3 <- tab_multi_manager(
  list_tables = list_data_2_tabs,
  list_explanatory_vars = list(
    act_size = c("ACTIVITY", "SIZE"),
    act_cj = c("ACTIVITY", "CJ")
  ),
  hrc = c(ACTIVITY = hrc_file_activity),
  dir_name = "tauargus_files/ex3",
  value = "TOT",
  freq = "N_OBS",
  secret_var = "is_secret_prim",
  totcode =  "Total"
)
#> --- Current table to treat:  act_size ---
#> --- Current table to treat:  act_cj ---
#> --- Current table to treat:  act_size ---

Par défaut, la fonction utilise un wrapper de la fonction tab_rtauargus(), appelé tab_rtauargus2(), pour appliquer le secret secondaire avec τ-Argus. De nombreux paramètres par défaut sont définis. En particulier :

Intervalle de protection fixé à 10 ;
Méthode de suppression fixée à “MOD(1,5,1,0,0) ;
Output au format csv.

Lors de son exécution, la fonction affiche à chaque itération quel tableau est traité.

La vignette Gérer la protection des tableaux liés fournit une présentation complète de la fonction tab_multi_manager().

Détail de la vignette

Authors: Julien Jamme & Nathanael Rastout
Last update: 21/09/2023
Version of rtauargus used: 1.2.0
Version of τ-Argus used : TauArgus 4.2.3
R version used : 4.2.3

summary ↑

Tau-Argus depuis R - données tabulées

¶ Package {rtauargus} ¶

Introduction

Présentation du package

But de ce document

Configuration

τ-Argus

Dépendances

Prise en main

Location de τ-Argus

Protéger un seul tableau avec la fonction tab_rtauargus().

Exemple minimal

Exemple avec une hiérarchie et pose du secret primaire via R

Données

Fichier hiérarchique

Secret primaire

Exécution de τ-Argus

Résultat

Protéger plusieurs tableaux en même temps, avec la fonction tab_muli_manager().

Données

Secret primaire

Exécution de τ-Argus

Détail de la vignette

¶
Package {rtauargus} ¶

Protéger un seul tableau avec la fonction `tab_rtauargus()`.

Protéger plusieurs tableaux en même temps, avec la fonction `tab_muli_manager()`.