Retrouver la valeur suivante avec LAG ou un MERGE

 

Dans un précédent article, la fonction LAG a été présentée. Il s’agissait alors de créer une nouvelle variable contenant la valeur précédente d’une variable existante. Pour récupérer la valeur suivante cette fois, je vous propose deux méthodes : utiliser la fonction LAG avec un tri décroissant ou faire un MERGE.

1. Trier par ordre décroissant et utiliser la fonction LAG : pour retrouver l’information suivante plutôt que l’information précédente, il vous suffit de trier les observations par ordre décroissant au préalable. Dans notre exemple précédent, (1, 2, 3, 4, 5) devient (2, 3, 4, 5, .). Afin de retrouver l’ordre d’origine, vous aurez besoin d’un second tri après. Cette fois-ci, c’est la dernière observation par patient qui sera manquante puisqu’il n’y a pas d’observation après pour un patient donné. En SAS, cela veut dire qu’il faudra utiliser LAST après le tri final ou FIRST avant le tri final.

proc sort data=test;
   by patient descending dt;
run;

data next_dt;
  set test;
  by patient;
  next_dt=lag(dt);
  if first.patient then next_dt=.;
run;

proc sort data=next_dt;
   by patient dt;
run;

2. Extraire la valeur suivante avec un MERGE : en extrayant la variable date sans sa première observation dans un jeu de donnée, on obtient la liste des valeurs suivantes. Il suffit ensuite d’ajouter ces valeurs au jeu de données d’origine pour avoir la 2ème date comme valeur suivante pour la première observation, etc. Un MERGE sans instruction BY est suffisant. Comme avant, on actualise la dernière observation par BY variable via LAST.

proc sort data=test;
   by patient dt;
run;

data next_dt;
   merge test
         test (firstobs=2 rename=(dt=next_dt));
run;

data next_dt;
   set next_dt;
   by patient;
   if last.patient then next_dt=.;
run;

Retrouver l’information précédente avec la fonction LAG

Lorsqu’un test médical est conduit plusieurs fois sur un patient, les résultats pourront être sauvegardés dans une variable par ordre chronologique. Pour étudier le changement entre deux examens, on peut créer une nouvelle variable contenant l’information précédente. Ceci est un exemple d’application de la fonction LAG qui récupère la valeur de l’observation précédente.

Ici je vous propose d’aborder cette fonction. Les exemples vont utiliser un jeu de donnée, nommé ‘test’, qui contient une variable identifiant chaque ‘patient’ et une variable date ‘dt’.  On peut donc avoir plusieurs dates par patient. L’objectif est de créer une nouvelle variable contenant la date précédente ou suivante.

1. La fonction LAG retrouve l’observation précédente : si une variable x à cinq valeurs (1, 2, 3, 4, 5) et qu’une nouvelle variable y contenant le LAG de x est créée, cette nouvelle variable aura (., 1, 2, 3, 4) comme valeurs. Ceci veut aussi dire qu’il y aura autant d’observations y que d’observations x. Les données devront être triées au préalable.

2. Obtenir la valeur précédente par sous groupe : la fonction LAG est indépendante d’une BY variable (ex : par patient). La première observation d’un patient devra pourtant être toujours manquante, puisqu’il n’y a pas de valeur avant pour ce patient. Pour que cette observation ne vienne pas du patient précédent, on la remplace par une valeur manquante grâce à FIRST. Mais la condition sur cette première observation sera faite après le LAG et non avant.

proc sort;
   data=test;
   by patient dt;
run;

data next_dt;
   set test;
   by patient;
   next_dt=lag(dt);
   if first.patient then next_dt=.;
run;

 

3. Retrouver une information précédente mais pas la dernière3.1 Sauter plusieurs observations : la fonction LAG peut être agrémentée d’un nombre pour préciser l’écart avec l’observation actuelle. LAG(x) est équivalent de LAG1(x). Ainsi dans notre exemple précédant (1, 2, 3, 4, 5), LAG2(x) donne (., ., 1, 2, 3).

3.2 Par sous-groupe : pour trouver l’information par sous-groupe, il faut ajouter un compteur. Celui-ci permet de définir une condition pour remplacer les dernières observations de chaque patient par des valeurs manquantes.

data next_dt2 (drop=cnt);
   set test;
   by patient;
  next_dt2=lag1(dt);
   cnt+1;
   if first.patient then cnt=1;
   if cnt in (1,2) then next_dt2=.;
run;

En résumé, la fonction LAG ‘fait descendre’ de z steps les données. On peut récupérer l’observation précédente contigue ou une information plus lointaine.