Comment trouver la valeur maximale de la variable pour chaque observation unique dans un jeu de données "empilé"

Question

Désolé pour le titre vauge.

Mon jeu de données ressemble essentiellement comme ceci:

ID X 
18 1 
18 1 
18 2 
18 1 
18 2 
369 2 
369 3 
369 3 
361 1 

ce que je veux est de trouver la valeur maximale de x pour chaque ID. Dans cet ensemble de données, ce serait 2 pour ID = 18 et 3 pour ID = 361.

Tous les commentaires seraient grandement appréciés.

Answer 1

Je ne comprends pas très bien votre exemple. Je ne peux pas imaginer que l'ensemble de données d'entrée a vraiment toutes les valeurs dans une observation. Voulez-vous dire quelque chose comme ça?

data sample; 
    input myid myvalue; 
datalines; 
18 1 
18 1 
18 2 
18 1 
18 2 
369 2 
369 3 
369 3 
361 1 
; 

proc sort data=sample; 
    by myid myvalue; 
run; 

data result; 
    set sample; 
    by myid; 

    if last.myid then output; 
run; 

proc print data=result; 
run; 

Cela vous donne ce résultat:

Obs myid myvalue 

1  18  2 
2  361  1 
3  369  3 

Answer 2

Utilisez un proc approprié avec la déclaration by. Par exemple,

data sample; 
    input myid myvalue; 
datalines; 
18 1 
18 1 
18 2 
18 1 
18 2 
369 2 
369 3 
369 3 
361 1 
; 
run; 

proc sort data=sample; 
    by myid; 
run; 

proc means data=sample; 
    var myvalue; 
    by myid; 
run; 

Answer 3

Proc moyens avec une déclaration de classe (de sorte que vous n'avez pas à trier) et de demander la statistique max est sans doute l'approche la plus simple (non testé):

 
data sample; 
    input id x; 
datalines; 
18 1 
18 1 
18 2 
18 1 
18 2 
369 2 
369 3 
369 3 
361 1 
; 
run; 


proc means data=sample noprint max nway missing; 
    class id; 
    var x; 
    output out=sample_max (drop=_type_ _freq_) max=; 
run; 

Check out la documentation SAS en ligne pour plus de détails sur Proc Means (http://support.sas.com/onlinedoc/913/docMainpage.jsp).

Answer 4

Vous pouvez essayer ceci:

PROC SQL; 
CREATE TABLE CHCK AS SELECT MYID, MAX(MYVALUE) FROM SAMPLE 
GROUP BY 1; 
QUIT; 

Answer 5

Je voudrais juste une sorte par x et id mettre la valeur la plus élevée pour chaque ID au sommet. NODUPKEY supprime tous les doublons ci-dessous.

proc sort data=yourstacked_data out=yourstacked_data_sorted; 
by DECENDING x id; 
run; 

proc sort data=yourstacked_data NODUPKEY out=top_value_only; 
by id; 
run; 

Answer 6

Si vous voulez conserver les deux tous les enregistrements et la valeur maximale de X par id, j'utiliser le PROC MOYENS aproche suivie d'une déclaration de fusion, ou vous pouvez trier les données par identifiant et DESCENDING X premier , puis utilisez l'instruction RETAIN pour créer le max_value directement dans le datastep:

PROC SORT DATA=A; BY ID DESCENDING X; RUN; 

DATA B; SET A; 
BY ID; 
RETAIN X_MAX; 
IF FIRST.ID THEN X_MAX = X; 
ELSE    X_MAX = X_MAX; 
RUN; 

Answer 7

quelques plus d'options sur-ingénierie qui pourrait être intéressant pour ceux qui ont besoin de le faire avec un ensemble de données vraiment grand, où la performance est plus préoccupante:

1. Si votre jeu de données est déjà trié par ID, mais pas par X dans chaque ID, vous pouvez toujours le faire en une seule étape de données sans aucun tri, en utilisant un maximum conservé dans chaque groupe. Vous pouvez également utiliser des moyens proc (selon la première réponse), mais avec une instruction by plutôt qu'une instruction class, ce qui réduit l'utilisation de la mémoire.

 
data sample; 
    input id x; 
datalines; 
18 1 
18 1 
18 2 
18 1 
18 2 
369 2 
369 3 
369 3 
361 1 
; 
run; 

data want; 
    do until(last.ID); 
    set sample; 
    by ID; 
    xmax = max(x, xmax); 
    end; 
    x = xmax; 
    drop xmax; 
run; 

1. Même si votre ensemble de données ne sont pas triées par ID, vous pouvez toujours le faire en une seule étape de données, sans les trier, à l'aide d'un objet de hachage pour garder la trace de la valeur x maximale que vous avez trouvée pour chaque ID au fur et à mesure.Ce sera un peu plus rapide que proc means et utilisera généralement moins de mémoire, car les moyens proc font divers calculs en arrière-plan qui ne sont pas nécessaires dans le jeu de données en sortie.

 
data _null_; 
    set sample end = eof; 
    if _n_ = 1 then do; 
    call missing(xmax); 
    declare hash h(ordered:'a'); 
    rc = h.definekey('ID'); 
    rc = h.definedata('ID','xmax'); 
    rc = h.definedone(); 
    end; 
    rc = h.find(); 
    if rc = 0 then do; 
    if x > xmax then do; 
     xmax = x; 
     rc = h.replace(); 
    end; 
    end; 
    else do; 
    xmax = x; 
    rc = h.add(); 
    end; 
    if eof then rc = h.output(dataset:'want2'); 
run; 

Dans cet exemple, sur mon PC, l'approche de hachage utilisé cette quantité de mémoire:

memory    966.15k 
    OS Memory   27292.00k 

vs autant pour un résumé de proc équivalent:

memory    8706.90k 
    OS Memory   35760.00k 

Non une mauvaise économie si vous en avez vraiment besoin pour l'augmenter!