Le jeu de données de résultats d’analyse (ARD) en R : les résultats sous forme de données avec cards et cardx

Calculez chaque résultat une seule fois sous forme de jeu de données tidy à une ligne par statistique — la norme de résultats d’analyse de CDISC — avec les packages pharmaverse cards et cardx, puis passez le même objet à un tableau, à un filtre ou à un graphique, de sorte que le calcul d’un résultat soit enfin séparé de son affichage

Un tutoriel complet et exécutable sur le jeu de données de résultats d’analyse (ARD) — la structure de données tidy, à une ligne par résultat, que la norme de résultats d’analyse de CDISC place au centre du reporting clinique. Découvrez ce qu’est un ARD et pourquoi les « résultats sous forme de données » comptent (cela sépare le calcul d’une statistique de la façon dont elle est affichée), puis construisez-en un avec les packages pharmaverse cards et cardx : ard_continuous() pour les statistiques de synthèse, ard_categorical() pour les effectifs et pourcentages, cardx::ard_stats_t_test() pour un résultat de test sous forme de données, et bind_ard() pour les empiler. Enfin, connectez l’ARD à un affichage avec gtsummary::tbl_ard_summary() et — puisque l’ARD n’est qu’un tibble — filtrez-le et tracez un seul nombre avec ggplot2. S’exécute sur les données publiques ADSL de pharmaverseadam, donc chaque ligne s’exécute.

Date de publication

1 juillet 2026

Modifié

8 juillet 2026

AstucePoints clés
  • Un ARD (jeu de données de résultats d’analyse) est constitué de vos résultats stockés sous forme de données — une ligne par statistique (une moyenne, un effectif, un pourcentage, une p-value), chacune étiquetée avec la variable qu’elle décrit, le groupe auquel elle appartient et la façon dont elle doit être formatée. C’est la structure de données au cœur de la norme de résultats d’analyse (ARS) de CDISC.
  • Il sépare le calcul d’un résultat de son affichage. Vous calculez chaque nombre une seule fois dans un jeu de données tidy ; un tableau, un listing ou une figure n’est alors qu’une vue de ce jeu de données — pas un nouveau calcul. Calculez une fois, affichez de multiples façons.
  • cards construit des ARD descriptifs. ard_continuous() vous donne N, la moyenne, l’écart-type, la médiane et les quartiles par groupe ; ard_categorical() vous donne n, N et les pourcentages.
  • cardx transforme des tests en ARD. ard_stats_t_test() exécute un t-test et renvoie l’estimation, la statistique, les degrés de liberté, l’IC et la p-value sous forme de lignes — un résultat de test que vous pouvez filtrer, sans le réexécuter.
  • L’ARD n’est qu’un tibble, donc un tableau, un filtre et un graphique en découlent tous. Passez-le à gtsummary::tbl_ard_summary() pour un tableau d’affichage, sous-ensemblez-le avec le [ de base pour extraire un nombre, ou transmettez les mêmes lignes à ggplot2.

Introduction

Vous avez calculé le tableau démographique, le tableau des événements indésirables et le résultat d’efficacité — trois fois, sur trois machines différentes, dans trois scripts différents. L’âge moyen vit à l’intérieur d’un objet gtsummary ; les effectifs d’événements vivent dans une mise en page rtables ; la p-value vit dans la sortie console d’un t.test(). Posez une simple question transversale — quel était l’âge moyen dans le bras placebo ? — et vous voilà à fouiller des cellules de tableau formatées pour récupérer un nombre qui était, à un moment donné, une simple valeur numérique.

Le jeu de données de résultats d’analyse (ARD) règle cela en renversant la question : et si chaque résultat n’était que… des données ? Un ARD est un jeu de données tidy avec une ligne par statistique calculée. L’âge moyen dans le bras placebo est une ligne. Le pourcentage de sujets de sexe féminin sous la dose élevée est une ligne. La p-value de comparaison des traitements est une ligne. Chaque ligne porte non seulement le nombre mais aussi son contexte — quelle variable, quel groupe, quelle statistique, et comment le formater. Voilà ce que signifient les « résultats sous forme de données » : un résultat calculé est stocké comme un enregistrement dans un jeu de données, et non figé dans une cellule de tableau formatée.

Cette idée est désormais une norme CDISC formelle. CDISC (Clinical Data Interchange Standards Consortium) — l’organisme à l’origine des modèles de données cliniques que l’industrie soumet aux autorités réglementaires — publie la norme de résultats d’analyse (ARS), qui spécifie l’ARD comme la structure lisible par la machine qui se situe entre les jeux de données d’analyse et les TLF (tableaux, listings et figures) finaux. Tout comme ADaM (Analysis Data Model) a standardisé les données prêtes pour l’analyse, ARS standardise les résultats d’analyse. En R, les packages pharmaverse cards et cardx construisent des ARD et les connectent à des affichages.

Voici le bénéfice, d’emblée — une figure tracée directement à partir d’un ARD, et non d’une analyse réexécutée :

Point-and-interval plot of mean age by treatment arm, computed from an Analysis Results Dataset. Three azure points sit close together near 74 to 76 years: Placebo at about 75.2, Xanomeline Low Dose at about 76.0, and Xanomeline High Dose at about 73.8, each with a vertical bar spanning plus or minus one standard deviation (roughly 8 to 9 years). The arms are well balanced on age. The caption notes that the mean and SD were read straight from the ARD rows, not recomputed.

La moyenne et l’écart-type derrière chaque point n’ont pas été recalculés pour le graphique — ils ont été filtrés depuis l’ARD que nous construisons ci-dessous. C’est toute la leçon : calculez les résultats une seule fois dans un jeu de données, puis mettez-les en tableau, filtrez-les ou tracez-les à partir du même objet.

Ce qu’est un ARD (et pourquoi les « résultats sous forme de données »)

Un script de reporting traditionnel calcule et met en forme d’un même souffle : il exécute un résumé et rend immédiatement un tableau. Le nombre et sa présentation sont soudés ensemble, si bien que le nombre est difficile à réutiliser et le tableau difficile à modifier sans réexécuter l’analyse.

Un ARD brise cette soudure en deux étapes nettes :

  1. Calculer — produire un jeu de données de résultats tidy, une ligne par statistique, avec un contexte complet (variable, groupe, nom de la statistique, valeur, format).
  2. Afficher — rendre n’importe quelle vue (un tableau gtsummary, une mise en page rtables, une figure) comme une transformation de ce jeu de données.

Les bénéfices sont les raisons pour lesquelles CDISC l’a standardisé : un résultat calculé une seule fois peut alimenter de nombreuses sorties (de sorte que la moyenne de votre tableau et la moyenne de votre figure sont, de façon prouvable, le même nombre) ; les résultats deviennent traçables et lisibles par la machine (une ligne d’ARD enregistre exactement ce qui a été calculé et comment) ; et un changement d’affichage ne risque jamais de changer une valeur, parce que la valeur existe déjà sous forme de données. La norme de résultats d’analyse formalise cela pour que les résultats puissent circuler entre outils et promoteurs comme le font déjà les jeux de données ADaM.

Le reste de cette leçon construit un ARD à partir d’un vrai jeu de données d’analyse et le connecte à un affichage.

Les données

Nous utilisons ADSL (le jeu de données d’analyse au niveau du sujet — une ligne par sujet, portant le traitement, les données démographiques et les indicateurs de population) fourni dans pharmaverseadam, l’étude pilote CDISC synthétique et libre de licence comparant le placebo à deux doses de Xanomeline. Il arrive sous forme de tibble, si bien que le premier geste est as.data.frame() — les fonctions cards et le sous-ensemblage en base R que nous utilisons partout attendent un data frame simple. Nous conservons aussi les trois vrais bras de traitement (en écartant les lignes d’échec de sélection, qui n’ont jamais été randomisées) et fixons leur ordre avec un facteur, pour que le placebo mène chaque tableau et chaque figure.

library(cards)

# ADSL is a tibble -> make it a plain data.frame first.
arms <- c("Placebo", "Xanomeline Low Dose", "Xanomeline High Dose")
adsl <- as.data.frame(pharmaverseadam::adsl)
adsl <- adsl[adsl$TRT01A %in% arms, ]           # keep the randomised arms
adsl$TRT01A <- factor(adsl$TRT01A, levels = arms)

adsl[1:5, c("USUBJID", "TRT01A", "AGE", "SEX", "RACE")]
      USUBJID               TRT01A AGE SEX  RACE
1 01-701-1015              Placebo  63   F WHITE
2 01-701-1023              Placebo  64   M WHITE
3 01-701-1028 Xanomeline High Dose  71   M WHITE
4 01-701-1033  Xanomeline Low Dose  74   M WHITE
5 01-701-1034 Xanomeline High Dose  77   F WHITE

TRT01A est le bras de traitement réel ; AGE, SEX et RACE sont les données démographiques que nous allons résumer. C’est tout ce dont l’ARD a besoin.

Construire un ARD continu avec ard_continuous()

Le premier ARD résume une variable continue. Pointez ard_continuous() sur les données, nommez la variable de regroupement avec by, et nommez la ou les variables à résumer. Il renvoie un tibble card — l’ARD — avec la batterie standard de statistiques (N, moyenne, écart-type, médiane, quartiles, min, max) pour chaque groupe.

library(cards)

arms <- c("Placebo", "Xanomeline Low Dose", "Xanomeline High Dose")
adsl <- as.data.frame(pharmaverseadam::adsl)
adsl <- adsl[adsl$TRT01A %in% arms, ]
adsl$TRT01A <- factor(adsl$TRT01A, levels = arms)

ard_age <- ard_continuous(adsl, by = TRT01A, variables = AGE)

# show the Placebo arm's statistics (the first block of rows).
# group1_level is a list-column, so unlist() it before the comparison.
ard_age[unlist(ard_age$group1_level) == "Placebo",
        c("group1_level", "variable", "stat_name", "stat_label", "stat")]
  group1_level variable stat_name stat_label   stat
1      Placebo      AGE         N          N     86
2      Placebo      AGE      mean       Mean 75.209
3      Placebo      AGE        sd         SD   8.59
4      Placebo      AGE    median     Median     76
5      Placebo      AGE       p25         Q1     69
6      Placebo      AGE       p75         Q3     82
7      Placebo      AGE       min        Min     52
8      Placebo      AGE       max        Max     89

Lisez une ligne : pour le bras placebo, la mean de AGE est 75.2. Chaque nombre de résumé que le tableau démographique pourrait jamais afficher est désormais une ligne que vous pouvez désigner. Le tibble card porte plus de colonnes que celles que nous avons imprimées — voici l’anatomie d’un ARD :

Colonne Ce qu’elle contient Exemple
group1 La variable de regroupement TRT01A
group1_level La valeur de regroupement pour cette ligne Placebo
variable La variable résumée AGE
stat_name De quelle statistique il s’agit pour cette ligne mean, sd, median, p25, N
stat_label Une étiquette lisible par un humain Mean, SD, Median
stat La valeur calculée 75.2093
context Le type d’analyse qui l’a produite continuous
fmt_fun Comment formater la valeur pour l’affichage arrondir à 1 décimale
warning / error Ce que le calcul a émis, le cas échéant généralement vide

Deux colonnes portent l’idée des « résultats sous forme de données ». stat est le nombre lui-même, stocké comme donnée plutôt que comme chaîne formatée ; fmt_fun enregistre comment l’afficher séparément de la valeur — de sorte que l’arrondi est une décision d’affichage appliquée plus tard, non figée dans le résultat. Cette séparation est tout l’intérêt de la norme.

Construire un ARD catégoriel avec ard_categorical()

Une variable catégorielle a besoin d’effectifs et de pourcentages plutôt que d’une moyenne. ard_categorical() a la même forme d’appel et renvoie, pour chaque niveau de la variable, l’effectif n, le dénominateur N et la proportion p.

library(cards)

arms <- c("Placebo", "Xanomeline Low Dose", "Xanomeline High Dose")
adsl <- as.data.frame(pharmaverseadam::adsl)
adsl <- adsl[adsl$TRT01A %in% arms, ]
adsl$TRT01A <- factor(adsl$TRT01A, levels = arms)

ard_sex <- ard_categorical(adsl, by = TRT01A, variables = SEX)

ard_sex[unlist(ard_sex$group1_level) == "Placebo",
        c("group1_level", "variable", "variable_level", "stat_name", "stat")]
  group1_level variable variable_level stat_name  stat
1      Placebo      SEX              F         n    53
2      Placebo      SEX              F         N    86
3      Placebo      SEX              F         p 0.616
4      Placebo      SEX              M         n    33
5      Placebo      SEX              M         N    86
6      Placebo      SEX              M         p 0.384

Pour le bras placebo, il y a 53 sujets de sexe féminin (n) sur 86 (N), soit une proportion de 0.616 (p) — les 61.6 % qu’un tableau démographique afficherait. Notez la colonne supplémentaire variable_level : un ARD catégoriel a besoin d’une ligne par catégorie, il enregistre donc à quel niveau (F ou M) appartient chaque n/N/p. L’ARD continu n’avait pas de telle colonne parce qu’une moyenne n’a pas de sous-niveaux.

Transformer un test en ARD avec cardx::ard_stats_t_test()

Les statistiques descriptives sont un type de résultat ; un test inférentiel en est un autre. Le package cardx étend cards aux tests statistiques — et il renvoie le test sous forme d’ARD, si bien qu’une p-value devient une ligne exactement comme une moyenne.

ard_stats_t_test() exécute un t-test à deux échantillons. Il compare exactement deux groupes, donc la variable by doit avoir exactement deux niveaux — nous sous-ensemblons d’abord le placebo versus la dose élevée.

library(cards)
library(cardx)

arms <- c("Placebo", "Xanomeline Low Dose", "Xanomeline High Dose")
adsl <- as.data.frame(pharmaverseadam::adsl)
adsl <- adsl[adsl$TRT01A %in% arms, ]
adsl$TRT01A <- factor(adsl$TRT01A, levels = arms)

# t-test needs exactly two groups: Placebo vs High Dose
two <- adsl[adsl$TRT01A %in% c("Placebo", "Xanomeline High Dose"), ]
two$TRT01A <- factor(two$TRT01A)

ard_tt <- ard_stats_t_test(data = two, by = TRT01A, variable = AGE)

ard_tt[ard_tt$stat_name %in%
         c("estimate", "statistic", "parameter", "p.value", "conf.low", "conf.high"),
       c("variable", "stat_name", "stat_label", "stat")]
  variable stat_name stat_label    stat
1      AGE  estimate  Mean Dif…   1.432
2      AGE statistic  t Statis…   1.087
3      AGE   p.value    p-value   0.279
4      AGE parameter  Degrees … 154.432
5      AGE  conf.low  CI Lower…   -1.17
6      AGE conf.high  CI Upper…   4.033

Chaque élément d’un t-test est désormais une ligne étiquetée : l’estimate est la différence d’âge moyen (environ 1.4 an, placebo moins dose élevée) ; statistic est la valeur t (1.09) ; parameter correspond aux degrés de liberté (de Welch, ≈154) ; conf.low/conf.high sont l’IC à 95 % (−1.2 à 4.0) ; et p.value vaut 0.28. L’intervalle englobe zéro et la p-value est bien au-dessus de 0.05 — les bras sont bien appariés sur l’âge, ce que l’on souhaite dans un essai randomisé. Le résultat du test est maintenant une donnée interrogeable, et non un bloc de texte console qu’il faut gratter.

Empiler des ARD avec bind_ard()

Un reporting réel a besoin de nombreux résultats ensemble — plusieurs variables, à la fois descriptifs et inférentiels. bind_ard() empile n’importe quel nombre d’ARD en un seul, parce qu’ils partagent tous la même structure de colonnes. C’est cet unique ARD empilé qu’un affichage consomme.

library(cards)

arms <- c("Placebo", "Xanomeline Low Dose", "Xanomeline High Dose")
adsl <- as.data.frame(pharmaverseadam::adsl)
adsl <- adsl[adsl$TRT01A %in% arms, ]
adsl$TRT01A <- factor(adsl$TRT01A, levels = arms)

ard_age <- ard_continuous(adsl, by = TRT01A, variables = AGE)
ard_sex <- ard_categorical(adsl, by = TRT01A, variables = SEX)

ard_demo <- bind_ard(ard_age, ard_sex)

# how many result rows, and for which variables
table(ard_demo$variable)

AGE SEX 
 24  18

ard_demo contient désormais chaque statistique d’âge et chaque effectif/pourcentage de sexe pour les trois bras dans un unique objet tidy — les résultats lisibles par la machine derrière un tableau démographique, prêts à afficher.

Connecter l’ARD à un affichage : gtsummary::tbl_ard_summary()

L’ARD est le calcul ; un tableau en est un affichage. gtsummary::tbl_ard_summary() prend un ARD pré-calculé et le met en page en un tableau de synthèse prêt à publier — il ne fait aucune statistique de son côté, il ne fait qu’agencer les nombres que l’ARD contient déjà.

library(cards)
library(gtsummary)

arms <- c("Placebo", "Xanomeline Low Dose", "Xanomeline High Dose")
adsl <- as.data.frame(pharmaverseadam::adsl)
adsl <- adsl[adsl$TRT01A %in% arms, ]
adsl$TRT01A <- factor(adsl$TRT01A, levels = arms)

ard_demo <- bind_ard(
  ard_continuous(adsl, by = TRT01A, variables = AGE),
  ard_categorical(adsl, by = TRT01A, variables = SEX)
)

tbl_ard_summary(ard_demo, by = "TRT01A")
Table 1
Characteristic Placebo1 Xanomeline Low Dose1 Xanomeline High Dose1
AGE 76.0 (69.0, 82.0) 78.0 (71.0, 82.0) 75.5 (70.0, 79.0)
SEX


    F 53 (61.6%) 55 (57.3%) 35 (48.6%)
    M 33 (38.4%) 41 (42.7%) 37 (51.4%)
1 Median (Q1, Q3); n (%)

Voilà le tableau démographique — l’âge en médiane (Q1, Q3), le sexe en n (%) — et pas une seule statistique n’a été recalculée pour le produire. Chaque cellule a été lue depuis ard_demo. Changez l’affichage (arrondir différemment, réordonner les lignes, passer à une mise en page rtables) et les résultats sous-jacents ne bougent jamais.

C’est aussi la façon la plus nette de voir cards versus gtsummary. L’ordinaire gtsummary::tbl_summary() calcule et affiche en un seul appel — pratique, mais les nombres vivent à l’intérieur de l’objet tableau. tbl_ard_summary() affiche un ARD que vous avez construit séparément, si bien que les résultats existent d’abord sous forme de données et que le tableau n’est qu’une vue. Utilisez tbl_summary() pour un besoin ponctuel rapide ; construisez un ARD lorsque les mêmes résultats doivent alimenter plusieurs sorties, être tracés, ou suivre la norme CDISC.

Les résultats sous forme de données : filtrer et tracer depuis l’ARD

Parce que l’ARD est un simple tibble, vous n’avez pas besoin d’une fonction spéciale pour réutiliser un résultat — le base R suffit. Filtrer l’ARD sur une seule statistique vous donne un data frame propre que vous pouvez imprimer, rapporter ou tracer. C’est exactement ainsi qu’a été réalisée la figure phare en haut de page : extrayez les lignes mean, extrayez les lignes sd, et transmettez-les à ggplot2.

library(cards)
library(ggplot2)

arms <- c("Placebo", "Xanomeline Low Dose", "Xanomeline High Dose")
adsl <- as.data.frame(pharmaverseadam::adsl)
adsl <- adsl[adsl$TRT01A %in% arms, ]
adsl$TRT01A <- factor(adsl$TRT01A, levels = arms)

ard_sex <- ard_categorical(adsl, by = TRT01A, variables = SEX)

# filter the ARD to the % of female subjects, per arm (base R)
female_pct <- ard_sex[ard_sex$stat_name == "p" & ard_sex$variable_level == "F", ]
pct <- data.frame(
  arm = factor(unlist(female_pct$group1_level), levels = arms),
  pct = 100 * as.numeric(female_pct$stat)
)

ggplot(pct, aes(x = arm, y = pct)) +
  geom_col(fill = "#3a86d4", width = 0.6) +
  geom_text(aes(label = paste0(round(pct), "%")), vjust = -0.4, size = 3.8, colour = "grey25") +
  labs(x = NULL, y = "Female subjects (%)",
       title = "Percentage female by arm, drawn straight from the ARD") +
  theme_minimal(base_size = 13) +
  theme(plot.title = element_text(face = "bold", size = 13))

Bar chart of the percentage of female subjects in each treatment arm, computed by filtering the categorical ARD to its proportion rows. Placebo is about 62 percent, Xanomeline Low Dose about 57 percent, and Xanomeline High Dose about 49 percent. All three bars are azure and the values are printed above each bar.

Rien ici ne recalcule un pourcentage : 100 * as.numeric(female_pct$stat) lit la proportion qui se trouve déjà dans l’ARD. Le tableau ci-dessus et cette figure rapportent maintenant les mêmes nombres par construction — c’est la garantie même que l’ARD est fait pour offrir.

🟢 Avec un agent IA

Demandez à Prova « comment ajouter une ligne de moyenne et d’écart-type à mon ARD cards et contrôler la façon dont chaque statistique est formatée avec la colonne fmt_fun ? » — elle répond en s’appuyant sur les leçons de ce pilier, avec du code cards/cardx exécutable que vous pouvez essayer sur les données pharmaverse d’exemple. The runtime is the judge. Demandez à Prova →

Problèmes fréquents

« no applicable method » ou d’étranges erreurs de ard_continuous() — vous avez passé un tibble. pharmaverseadam::adsl est un tibble, et le correctif le plus propre est de le convertir d’abord : adsl <- as.data.frame(pharmaverseadam::adsl). Faites-le une fois en haut de chaque bloc ; le sous-ensemblage en base R (adsl[...]) et les appels cards se comportent tous deux bien sur un data frame simple.

ard_stats_t_test() renvoie des statistiques vides pour trois bras. Un t-test à deux échantillons compare exactement deux groupes, donc la variable by doit avoir exactement deux niveaux. TRT01A a trois bras (plus les lignes d’échec de sélection si vous ne les avez pas écartées). cards ne lève pas d’erreur console ici — il capture le message « grouping factor must have exactly 2 levels » dans la colonne error de l’ARD et laisse stat vide. Sous-ensemblez les deux bras que vous voulez et re-factorisez pour qu’aucun niveau vide ne subsiste : two <- adsl[adsl$TRT01A %in% c("Placebo", "Xanomeline High Dose"), ]; two$TRT01A <- factor(two$TRT01A).

Vous avez tenté shuffle_ard() — elle est dépréciée. D’anciens tutoriels pivotent un ARD avec shuffle_ard(), mais elle est dépréciée dans cards 0.8.0. Pour combiner des ARD, utilisez bind_ard() (empilement), et pour en afficher un, utilisez gtsummary::tbl_ard_summary() ; le remodelage pour une mise en page personnalisée vit désormais dans les packages d’affichage en aval (tfrmt::shuffle_card()), et non dans cards.

Un filtre sur group1_level (ou variable_level) renvoie zéro ligne. Les colonnes stat, group1_level et variable_level d’un tibble card sont des colonnes-listes — et group1_level contient des facteurs. Comparer une colonne-liste avec == (par ex. ard$group1_level == "Placebo") renvoie silencieusement tout FALSE, si bien que le sous-ensemble est vide. unlist() d’abord la colonne pour que == compare des valeurs : ard[unlist(ard$group1_level) == "Placebo", ]. Même règle quand vous extrayez un nombre — sous-ensemblez les lignes, puis convertissez la colonne-liste stat : rows <- ard[unlist(ard$group1_level) == "Placebo" & ard$stat_name == "mean", ]; as.numeric(rows$stat).

Questions fréquentes

Un ARD est un jeu de données tidy dans lequel chaque ligne est un résultat calculé — une statistique telle qu’une moyenne, un effectif, un pourcentage ou une p-value — étiquetée avec la variable qu’elle décrit, le groupe auquel elle appartient, le nom de la statistique, sa valeur et la façon de la formater. C’est la structure lisible par la machine que la norme de résultats d’analyse de CDISC place entre les jeux de données d’analyse et les tableaux et figures finaux, afin que les résultats puissent être stockés, tracés et réutilisés sous forme de données.

Cela signifie stocker un résultat calculé comme un enregistrement dans un jeu de données au lieu de le figer dans une cellule de tableau formatée. Le nombre 75.2 pour « âge moyen, bras placebo » devient une ligne que vous pouvez interroger, filtrer et réutiliser — indépendamment de toute décision sur la façon de l’arrondir ou de le disposer. Parce que le calcul est séparé de l’affichage, le même résultat peut alimenter un tableau, un listing et une figure et être, de façon prouvable, identique dans chacun.

Utilisez le tbl_summary() de gtsummary pour un tableau de synthèse rapide en un seul appel, quand les nombres n’ont besoin d’apparaître que dans ce seul tableau. Utilisez cards pour construire d’abord un ARD — quand les mêmes résultats doivent alimenter plusieurs sorties, être traçables ou suivre la norme CDISC — puis affichez-le avec tbl_ard_summary(). En bref : tbl_summary() calcule et affiche ensemble ; cards + tbl_ard_summary() calcule d’abord dans un jeu de données puis affiche.

Trois raisons ont conduit CDISC à le standardiser. Cohérence : un résultat calculé une seule fois dans un ARD peut alimenter de nombreuses sorties, si bien qu’un tableau et une figure ne peuvent pas se contredire silencieusement. Traçabilité : chaque ligne d’ARD enregistre exactement ce qui a été calculé, sur quel groupe, avec quel résultat — auditable et lisible par la machine. Séparation des préoccupations : changer un affichage ne peut jamais changer une valeur, parce que la valeur existe déjà sous forme de données. Ensemble, cela rend le reporting reproductible et portable entre outils et promoteurs.

cards construit des ARD descriptifs — des statistiques de synthèse avec ard_continuous() et des effectifs/pourcentages avec ard_categorical() — plus des utilitaires comme bind_ard(). cardx (cards extra) l’étend aux tests et modèles statistiques, les renvoyant eux aussi sous forme d’ARD : ard_stats_t_test(), ANOVA, régression, et plus encore. Les résumés descriptifs viennent de cards ; les tests viennent de cardx.

Testez vos connaissances

En utilisant l’objet adsl de cette leçon (les trois bras randomisés), construisez un ARD catégoriel pour RACE, puis lisez — avec le base R, sans recalculer — le pourcentage de sujets blancs dans le bras placebo.

ard_categorical(adsl, by = TRT01A, variables = RACE) vous donne n, N et p par niveau de race et par bras. Filtrez l’ARD résultant sur les lignes où stat_name == "p", unlist(variable_level) == "WHITE" et unlist(group1_level) == "Placebo" (unlist les colonnes-listes pour que == compare des valeurs, pas des listes), puis convertissez la valeur : as.numeric(rows$stat) * 100.

library(cards)

arms <- c("Placebo", "Xanomeline Low Dose", "Xanomeline High Dose")
adsl <- as.data.frame(pharmaverseadam::adsl)
adsl <- adsl[adsl$TRT01A %in% arms, ]
adsl$TRT01A <- factor(adsl$TRT01A, levels = arms)

ard_race <- ard_categorical(adsl, by = TRT01A, variables = RACE)

rows <- ard_race[ard_race$stat_name == "p" &
                 unlist(ard_race$variable_level) == "WHITE" &
                 unlist(ard_race$group1_level) == "Placebo", ]
round(as.numeric(rows$stat) * 100, 1)   # % White in the placebo arm -> 90.7

La valeur est lue directement depuis la ligne de proportion (p) de l’ARD — pas de table(), pas de re-tabulation. C’est là tout l’intérêt : une fois que le résultat est une donnée, le réutiliser n’est qu’un filtre.

A. Un sujet de l’étude B. Une statistique calculée (par ex. la moyenne de AGE dans le bras placebo) C. Une cellule de tableau formatée, y compris son arrondi et son style

B. Chaque ligne d’un jeu de données de résultats d’analyse est une statistique calculée, étiquetée avec sa variable, son groupe, son nom, sa valeur et son format. A décrit les données d’analyse (ADSL est une ligne par sujet) ; un ARD est une ligne par résultat. C est faux parce que la valeur et son formatage sont gardés séparés — le nombre vit dans stat, la règle d’affichage vit dans fmt_fun — ce qui est exactement ce qui permet à un résultat d’alimenter de nombreux affichages.

Conclusion

Un ARD, ce sont vos résultats transformés en données : une ligne par statistique, chacune avec le contexte nécessaire pour l’afficher. Ce seul changement — calculer une fois dans un jeu de données, afficher de multiples façons — est ce que formalise la norme de résultats d’analyse de CDISC, et ce que vous donnent en R les packages pharmaverse cards et cardx. Construisez des résultats descriptifs avec ard_continuous() et ard_categorical(), transformez des tests en résultats avec cardx::ard_stats_t_test(), empilez-les avec bind_ard(), et affichez le tout avec gtsummary::tbl_ard_summary(). Parce que l’ARD n’est qu’un tibble, les mêmes résultats alimentent aussi un filtre en base R ou une figure ggplot2 — de sorte que votre tableau, votre listing, et votre graphique rapportent, de façon prouvable, les mêmes nombres. Calculez le résultat une seule fois ; que chaque sortie en soit une vue.

Note

Cette leçon est reproductible : chaque résultat de cette page a été produit par le code montré — copiez n’importe quel bloc et exécutez-le pour les reproduire. The runtime is the judge.

Leçons connexes

  • Le tableau démographique rtables — le même résultat démographique construit comme un affichage de qualité soumission ; un ARD est la couche de résultats tidy qui peut l’alimenter. · Le tableau d’efficacité : ANCOVA et moyennes LS — un résultat modélisé (le genre que cardx transforme aussi en ARD) mis en page avec rtables/tern. · Créer ADSL en R avec admiral — le jeu de données d’analyse au niveau du sujet qu’un ARD résume.
  • Où cela s’inscrit : construire ADaM avec admiral (ADSL, ADVS, ADTTE) → produire les résultats — un ARD (vous êtes ici) est la couche de résultats tidy et standardisée — → générer les tableaux, listings et figures (les tableaux démographique, des événements indésirables et d’efficacité ; la figure de Kaplan-Meier) → empaqueter la soumission.
Cette page vous a-t-elle été utile ?

Recevez les nouvelles leçons R & Python par e-mail

Pratique, reproductible, sans spam. Désinscription à tout moment.

Double opt-in. Nous ne partageons jamais votre e-mail.

Partager cette pageXLinkedInRedditHN

Réutilisation

Citation

BibTeX
@online{2026,
  author = {},
  title = {Le jeu de données de résultats d’analyse (ARD) en R : les
    résultats sous forme de données avec cards et cardx},
  date = {2026-07-01},
  url = {https://www.datanovia.com/learn/pharma-clinical/04-tlf-generation/ard-analysis-results-cards},
  langid = {fr}
}
Veuillez citer ce travail comme suit :
“Le jeu de données de résultats d’analyse (ARD) en R : les résultats sous forme de données avec cards et cardx.” 2026. July 1. https://www.datanovia.com/learn/pharma-clinical/04-tlf-generation/ard-analysis-results-cards.