Etiqueta: SAS

Combinando três tabelas com o left join

Utilizando as informações do post Como combinar tabelas no SAS utilizando left join e full join, vamos imaginar que não tenhamos apenas duas tabelas, mas sim três, sendo que a terceira tabela contém as notas dos alunos que cursam Física:
Para montar uma única query que traga a nota de física, basta continuar o left join:
* notas dos alunos de calculo incluindo as de fisica dos que fizeram;
proc sql;
    create table exemplo_left_join as
    select a.*, b.nota_estat, c.nota_fis
        from turma_calc as a
          left join (select * from turma_estat ) as b
          on a.nome = b.nome
            left join (select * from turma_fis) as c
            on a.nome= c.nome;
run;
E você poderia inclusive filtrar antes de aplicar o left join. Como?
Bem, para quem leu o post SQL dentro do SAS sobre SQL fica bem claro o que foi feito acima: foi aplicado um left join em uma base construída entre parênteses. Ou seja, se para extrair as informações da turma de Física usamos select * from turma_fis, pra extrair os alunos aprovados na disciplina bastaria utilizar select * from turma_fis where Nota_Fis >= 6, teríamos então:
* excluindo os alunos reprovados em fisica;
proc sql;
    create table exemplo_left_join_2 as
    select a.*, b.nota_estat, c.nota_fis
    from turma_calc as a
    left join (select * from turma_estat ) as b
      on a.nome = b.nome
    left join (select * from turma_fis where Nota_Fis >= 6) as c
      on a.nome= c.nome;
run;
Agora que você sabe extrair informações utilizando o SQL e sabe que você pode fazer o que quiser dentro do parênteses antes de aplicar o left join, você poderia inclusive ser mais ousado e criar uma marcação de alunos aprovados, onde o campo Aprovado receberia 1 quando o aluno tem nota superior ou igual a 6 e 0 caso contrário:
* cria uma flag = 1 para trazer quem foi aprovado em fisica e estatistica;
proc sql;
    create table exemplo_left_join_3 as
    select a.*, b.Aprovado_Estat, c.Aprovado_Fis
    from turma_calc as a
    left join (
            select *, case when Nota_Estat >= 6 then 1
            else 0 end as Aprovado_Estat from turma_estat ) as b
      on a.nome = b.nome
    left join (
             select *, case when Nota_Fis >= 6 then 1
             else 0 end as Aprovado_Fis from turma_fis) as c
      on a.nome= c.nome;
run;

Como combinar tabelas no SAS utilizando left join e full join

Provavelmente a tarefa mais comum de alguém que trabalha com dados seja combinar diferentes tabelas para se obter toda a informação que precisa. Por exemplo, se em uma tabela você tiver o nome dos seus clientes e a informação de idade em uma base de dados, e em uma segunda tabela tiver informações como endereço e sexo, é bem provável que ao fazer um estudo, um modelo estatístico, você tenha que combinar estas duas tabelas. Vamos ver agora como combinar duas tabelas de algumas formas diferentes.

Vamos utilizar como exemplo duas turmas da faculdade, uma do curso de Cálculo e outra do curso de Estatística.Podemos ter alguns alunos matriculados em uma delas e não matriculados na outra e vice-versa. As duas tabelas abaixo contêm os alunos de cada turma, o sexo, a idade e a nota final da disciplina:

Caso alguém ainda não saiba criar sua própria tabela para treinar, segue o código utilizado para gerar as que serão utilizadas aqui:

data turma_calc;
    length nome $22.;
    input Nome $ Sexo $ Idade Nota_Calc;
    datalines;
      Roberto M 22 10
      Maria F 24 10
      Pedro M 17 6
      Renata F 18 9
      Andre M 23 9
      Marcos M 27 8
      Patricia F 19 7.5 
      Luciana F 19 6.2
      Adriana F 22 4.5 
      Fernando M 21 6.6 
      Felipe M 20 7
      Flavia F 20 6
      Fabio M 18 1
;
run;

data turma_estat;
    length nome $22.;
    input Nome $ Sexo $ Idade Nota_Estat;
    datalines;
      Roberto M 22 4 
      Maria F 24 3
      Jose M 19 6 
      Renata F 18 8
      Andre M 23 9
      Alexandre M 17 8
      Patricia F 19 6 
      Luciana F 15 6
      Fernanda F 29 5
      Fernando M 21 6 
      Marcelo M 17 5 
      Flavia F 20 7 
      Fabio M 18 5
;
run;

Vamos supor que você queira completar a primeira tabela com as notas de estatística para os alunos que cursaram as duas matérias, mas quer manter os demais também na tabela. Ou seja, pensando em dois conjuntos, você quer adicionar a informação que está na intersecção dos conjuntos A e B à informação do conjunto A. Abaixo temos a representação desse caso em um Diagrama de Venn seguido pelo código em SAS e a tabela de saída deste código:

* traz as notas de estatisticas para a tabela com os alunos de calculo;
proc sql;
create table exemplo_1 as
    select a.*, b.*
    from turma_calc as a
    left join turma_estat as b
    on a.nome = b.nome;
run;
E se você quiser apenas os alunos que cursaram somente cálculo, excluindo quem cursou a outra disciplina:
* traz os alunos que cursaram apenas Calculo;
proc sql;
    create table exemplo_2 as
    select a.*, b.*
    from turma_calc as a
    left join turma_estat as b
    on a.nome = b.nome
    where b.nome is NULL;
run;
Caso você não quisesse essa última coluna, bastaria não ter selecionado nada da tabela b:
proc sql;
    create table exemplo_2b as
    select a.*
    from turma_calc as a
    left join turma_estat as b
    on a.nome = b.nome
    where b.nome is NULL;
run;
Se quiser trazer os alunos das duas turmas:
* traz todos os alunos das duas turmas;
proc sql;
    create table exemplo_3 as
    select coalesce (a.nome, b.nome) as Nome
             , coalesce (a.sexo, b.sexo) as Sexo
             , coalesce(a.idade, b.idade) as Idade
             , a.*
             , b.*
    from turma_calc as a
    full join turma_estat as b
    on a.nome = b.nome;
run;
 
Se você não quiser os alunos que cursaram as duas matérias, quiser apenas quem cursou uma:
* traz os alunos que cursam somente um dos dois cursos;
proc sql;
    create table exemplo_4 as
    select coalesce (a.nome, b.nome) as Nome
             , coalesce(a.sexo, b.sexo) as Sexo
             , coalesce(a.idade, b.idade) as Idade
             , a.*
             , b.*
    from turma_1 as a
    full join turma_2 as b
    on a.nome = b.nome
    where a.nome is NULL or b.nome is NULL;
run;
Se você já programou em sas ou sql, também já ouviu falar do right join, que muda muito pouco com relação ao left join. Como o próprio nome implica, você vai inverter a ordem das tabelas que serão unidas. Veja abaixo uma imagem completa que descreve todas as funções join do sql:
Imagem retirada do site Guia DBA

 

Dúvidas? Erros? Deixe um comentário ou um e-mail.

Como obter a frequência de uma variável no SAS

Mencionei o comando proc freq do SAS no post Frequência no R utilizando o pacote Hmisc. Agora, vamos nos aprofundar um pouco e ver o que é possível fazer com este comando.

O proc freq traz a frequência das variáveis que você quer analisar ou fazer qualquer tipo de análise descritiva, ou seja, traz o número de vezes que determinado valor da variável aparece. A sintaxe mais simples do comando é:
proc freq data= base_de_dados; 
    table variavel1 variavel2 ... variaveln; 
run;
Vamos utilizar os dados de crédito german_credit_2 como exemplo.
Assim como já fizemos no R, no post Árvore de Decisão no R, vamos discretizar as variáveis Creditability e CreditAmount, para só depois gerarmos as frequências.
No caso de Creditability, a discretização serve para visualizar melhor quem é bom e quem é mau pagador. No caso de CreditAmount, não conseguimos gerar uma frequência que seja útil, pois a variável é contínua. Pior ainda, se a base for muito grande, o comando muito provavelmente não irá funcionar. Afinal de contas, você estará trazendo o número de vezes que cada valor aparece. Separar em intervalos é o ideal nesse caso.
Note que no meu caso, a base foi importada para o SAS com o nome german_credit_21.
**** discretiza variaveis creditability e amount ****;
data german_credit_21_v2;
    set german_credit_21;

    length d_creditability $4.;
    if creditability = 1 then
    d_creditability = 'good';
    else d_creditability = 'bad';

    length d_creditAmount $9.;
    if creditAmount <= 2500 then
    d_creditAmount = '0000-2500';
    else if creditAmount > 2500 and creditAmount <= 5000 then
    d_creditAmount = '2500-5000';
    else d_creditAmount = '+5000';

run;

**** Frequencia de Creditability e Amount ****;
proc freq data= german_credit_21_v2;
    table d_creditability d_creditAmount;
run;
Na primeira tabela é possível ver a frequência e qual o percentual que representa do todo. Temos 300 clientes maus, sendo que isso representa 30% da nossa população. Além disso, temos também a frequência acumulada. Temos, na segunda tabela, 537 clientes que possuem dívida entre 0 e 2500, e 812 clientes que possuem entre 0 e 5000, sendo que esses clientes representam 81,20% da nossa população.
É possível também obter a frequência cruzada, ou seja, quantos clientes bons e ruins há em cada faixa de dívida:
**** Frequencia Cruzada de Creditability e Amount ****;
proc freq data= german_credit_21_v2 ;
    table d_creditability*d_creditAmount;
run;
E se você quiser deixar a tabela um pouco menos poluída, mantendo apenas a frequência, utilize o norow, nocol e/ou nopercent:
**** Nao traz frequencia por linha, coluna nem percentual ****;
proc freq data= german_credit_21_v2;
    table d_creditability*d_creditAmount / norow nocol nopercent;
run;
Também é possível salvar a tabela de frequência utilizando o out:
**** Cria uma tabela de output chamada tabela_frequencia ****;
proc freq data= german_credit_21_v2;
    table d_creditability*d_creditAmount / out= tabela_frequencia norow nocol nopercent;
run;
E se você quiser ordenar a tabela de frequência, basta acrescentar o order = Freq:
**** Sem ordenar ****;
proc freq data= german_credit_21_v2 ;
    table Guarantors;
run;

**** Ordena pela frequencia ****;
proc freq data= german_credit_21_v2 order= freq;
    table Guarantors;
run;
Assim como fizemos para o Creditability, nós poderíamos ter atribuído nomes ao invés de índices ao Guarantors. Porém, para não alterarmos nossa base original, poderíamos simplesmente aplicar uma formatação:
**** formata o nome ****;
proc format;
   value formatacao
        1 = 'none'
        2 = 'co-applicant'
3 = 'guarantor';
run;

**** gera frequencia e apresenta com nome formatado ****;
proc freq data = german_credit_21;
   tables Guarantors;
   format Guarantors formatacao.; 
run;

Trabalhando com espaços e acentos no SAS

A pior coisa é utilizar campos com espaços em branco e acentos quando se está programando. Não é recomendável e muitas vezes resulta em erros. Porém, às vezes temos que lidar com isso porque alguém construiu uma base com campos dessa forma e não quer mudar.

No SAS é mais fácil lidar com isso, basta acrescentar aspas e a letra n. É bem semelhante quando você utiliza data, só que precisa trocar o ‘d’ por ‘n’.

Vamos supor que você receba os dados da turma de alunos do post Visualizando seus dados: histograma e queira criar uma marcação chamada Reprovação que receberá o número 1 para alunos que tiraram notas menor que 6, basta você criar o campo ‘Reprovação’n:

data dados_v2;
    set dados;
    if notas < 6 then 'Reprovação'n = 1;
    else 'Reprovação'n = 0;
run;

Poderíamos também cair em uma situação que seria necessário criar um campo Data de Atualização com a data do dia de hoje. Para isso, temos duas opções:

## primeira opcao:
data dados_v2;
    set dados;
    'Data de Atualização'n = today();
run;

## segunda opcao:
data dados_v2;
    set dados;
    'Data de Atualização'n = '13JUL2016'd;
run;

Contador e função oposta ao lag no SAS

Veja que exercício de lógica interessante:

Pense em uma base com clientes que possuem vários carros. Você tem linhas contendo o nome do cliente, o nome do carro que ele possui e a data de compra do veículo. Você precisa descobrir quais clientes possuem apenas um carro. A que eu vou demonstrar talvez não seja a mais eficiente, até porque eu precisei de alguns dados ao longo do estudo, como por exemplo qual a ordem em que o veículo foi comprado. Sem isso, não sei se eu teria pensado de outra forma. O legal da forma que foi feito o tratamento é que trabalha o raciocínio lógico e ainda apresenta alguns algoritmos úteis.

O passo a passo utilizado é o seguinte: ordene seus dados pelo nome e data de compra do veículo; crie um contador para representar se é o primeiro carro que aparece do cliente; crie uma coluna adicional para saber qual o contador da linha seguinte. Veja que se você tiver na linha 10 o valor 1 no contador, e na linha 11 você tiver o valor 2, é sinal de que o cliente possui pelo menos dois veículos. No entanto, se você tiver o valor 1 no contador da linha 10 e o valor 1 no contador da linha 11, o seu cliente da linha 10 possui apenas 1 carro.

Foi falado um pouco sobra a função lag() do SAS no post Média Móvel (Bônus: Código SAS e função lag). Ela simplesmente pega o valor da linha de cima da coluna que você quer. Por exemplo, se eu fizer lag(conta_carro), eu vou saber qual o valor da coluna conta_carro da linha anterior a que estou verificando. No caso apresentado nesse post, precisamos de uma função que faça o contrário da lag, ao invés de retornar o valor da linha anterior, deve retornar o valor da linha seguinte. Você verá que não existe uma função pronta para esse caso, mas o script é bem simples e se encontra na Parte 5 do código abaixo.

Veja o exemplo completo que você pode simular e acompanhar o passo a passo explicado acima:
**** Parte 1: Cria uma base de clientes ****;
data base_clientes;
    input nome $ carro $ DtCompra mmddyy8.;
    cards;
    Andre Onix 02/05/15
    Andre Palio 12/10/13
    Andre Uno 01/05/14
    Paulo Idea 10/06/15
    Jose Vectra 01/04/16
    Jose Eco 12/05/16 28
    Maria Corsa 10/25/14
    Maria Celta 02/01/16
    Renata Onix 02/09/12
    Renata Palio 06/05/11
    Renata Fit 02/11/16
    Renata Civic 05/22/14
    Michael Fit 07/13/15
    Bianca Clio 09/05/15
    Thais March 08/05/16
    Renan Palio 11/05/13
    Renan Gol 11/05/14
    ;
run;

**** Parte 2: Trata a variavel data ****;
data base_clientes_v2;
    set base_clientes;
    format DtCompra date9.;
run;

**** Parte 3: Ordena pelo nome do cliente e data da compra do veiculo ****;
proc sort data= base_clientes_v2; by nome DtCompra; run;

**** Parte 4: Cria um contador do numero de carros = conta qtas vezes o nome aparece****;
data base_clientes_v3;
    set base_clientes_v2;
    by nome;
    primeiro = first.nome;
    ultimo = last.nome;
    if primeiro = 1 then
    conta_carro = 1;
    else conta_carro+1;
run;

**** Parte 5: Cria uma coluna com o valor da linha seguinte da coluna conta_carro ****;
data base_clientes_v4;
    recno=_n_+1;
    set base_clientes_v3 end=last;
    if not last
    then set base_clientes_v3 (keep=conta_carro rename=(conta_carro=next_conta_carro)) point=recno;
    else call missing(next_conta_carro);
run;

**** Parte 6: Mantem apenas quem tem conta_carro = 1 e que a proxima linha eh 1 tb ****;
data clientes_com_um_carro;
    set base_clientes_v4;
    if conta_carro = 1 and next_conta_carro = 1;
run;

Seja mais ágil utilizando firstobs e inobs no SAS

Quando se trabalha com milhões de dados, qualquer tratamento vai consumir alguns bons minutos – ou até horas – do seu dia. Ou seja, se você escrever seu código, rodar e ele apresentar algum erro, lá se vai uma parte do seu dia. Como ninguém é perfeito, esse processo de escrever + executar + problemas se repete várias vezes ao longo do dia. Logo, você vai gastar horas para escrever um código, muitas vezes simples, e vai passar horas ocioso. Porque você vai escrever um trecho do código, vai colocar para rodar, vai esperar alguns minutos e aí sim vai resolver um problema. Para depois fazer isso de novo. E aí segue seu dia, chato e improdutivo.

Evitar o problema descrito é mais simples do que parece. Ao menos parte dele é solucionado testando em uma amostra. Por exemplo, você quer converter o formato de data da sua base. Não escreva o código e fique lá 20 minutos rodando enquanto você não faz nada, ou finge fazer. Teste essa conversão em 10 linhas da base de dados e veja o que ocorre. Se o processo for grande, envolver várias etapas, siga testando com essas 10 linhas fazendo todos os tratamentos, seja enriquecendo a base com dados de outras fontes, seja tratando os campos. Para pegar apenas 10 linhas, você tem as duas opções abaixo, uma para quem usa data step e outra para quem usa proc sql:

* primeira opcao via data step
* seleciona do primeiro ao decimo elemento
* util caso voce queira selecionar elementos do meio da tabela;
data seleciona_amostra;
    set base (firstobs = 1 obs = 10);
run;

* segunda opcao via proc sql;
proc sql inobs = 10;
    select * from base;
run;

Bem simples. Desta forma não precisa mais escrever um trecho, deixar rodando por 1h para só depois checar se deu certo.

Espero que tenha ajudado. Dúvidas, sugestões ou críticas é só escrever aí embaixo.

Macros e a expressão Let no SAS

No post As boas práticas de programação foi mencionado que o código deveria ser o menos estático possível? No SAS isso pode ser feito muito bem com a criação de Macros e com a expressão %LET.

CONCEITO DE MACROS

De acordo com o Wikipedia “Uma macro (abreviação para macroinstrução), em ciência da computação, é uma regra ou padrão que especifica como uma certa sequência de entrada (frequentemente uma sequência de caracteres) deve ser mapeada para uma substituição de sequência de saída (também frequentemente uma sequência de caracteres) de acordo com um procedimento definido.”

Ou seja, uma macroinstrução é uma sequência de regras que o programa deve seguir. Quando você cria uma macro, você cria um programinha que vai executar uma série de procedimentos.

MACROS NO SAS

No SAS, assim como em outros programas, você pode deixar uma série de nomes flexíveis dentro da sua sequência de procedimentos, para que eles rodem diversas vezes soltando saídas diferentes.

Por exemplo, suponha que a gente tenha a base FATURA_YYYYMM gerada mensalmente com as faturas dos clientes no mês corrente. Você está realizando um estudo com clientes que possuem faturas de valor acima de R$ 200,00. Porém, para seu estudo, você vai pegar clientes dos primeiros três meses do ano. Se a pessoa não conhece muito sobre macros, é esperado que ela faça um código como esse:

data faturas_jan;
     set fatura_201601;
     if vlr_fatura > 200;
run;

data faturas_fev;
     set fatura_201602;
     if vlr_fatura > 200;
run;

data faturas_mar;
     set fatura_201603;
     if vlr_fatura > 200;
run;

Não parece a melhor maneira. Alguém mais calejado já estaria quebrando a cabeça imaginando que existe um jeito mais prático. Existe, é utilizando as macros do SAS.

No começo parece até algo mais complicado, mas é bem simples. A sintaxe é da seguinte forma:

%macro nome_da_macro(input 1, input2, ...);
     comando 1;
     comando 2;
     .
     .
     .
%mend;
%nomedamacro(input 1, input2, ...);

Sendo assim, podemos criar a macro EXTRAI_FATURA na qual vamos colocar como inputs os nomes das bases que serão lidas e como output as bases de saída:

%macro extrai_fatura(input, output);
data &input;
     set &output;
     if fatura > 200;
run;
%mend;

%extrai_fatura(fatura_201601, extracao_janeiro);
%extrai_fatura(fatura_201602, extracao_fevereiro);
%extrai_fatura(fatura_201603, extracao_marco);

Veja que a macro está lendo as bases que declaramos como input e está soltando os resultados em bases com o nome que passamos como output (extracao + nome do mês).

Note que precisamos colocar o caractere ‘&’ antes do nome das variáveis que serão substituídas. Note também, que a macro pode ficar ainda mais flexível com você passando o valor que quiser em cada extração:

%macro extrai_fatura(input, output, valor);
data &input;
     set &output;
     if fatura > &valor;
run;
%mend;

%extrai_fatura(fatura_201601, extracao_janeiro, 100);
%extrai_fatura(fatura_201602, extracao_fevereiro, 200);
%extrai_fatura(fatura_201603, extracao_marco, 300);

Nessa segunda macro, podemos colocar o valor que quisermos em cada extração. A primeira execução vai ler a fatura_201601 e retornar a extracao_janeiro apenas com clientes que possuem fatura acima de R$ 100,00. A segunda execução lê a fatura_201602 e retorna a extracao_fevereiro apenas com os clientes de fatura acima de R$ 200,00.

%LET NO SAS

A expressão %LET é mais fácil ainda que a macro, embora não ache ela tão poderosa.

Essa expressão também serve para alterar parâmetros no meio do seu código, porém, diferentemente da macro, você declara a variável uma vez no início do código. Uma das facilidades que eu vejo no LET é que permite você rodar o código por partes, o que facilita bastante para pegar erros. Facilita para processos executados periodicamente em que se altera algumas variáveis de inputs. Vamos supor que agora você não vai fazer um estudo, mas você quer fazer uma campanha com os clientes de alta renda e todo mês, assim que a base de faturamento for gerada, você vai pegar os clientes que possuem faturas acima de R$ 500,00. Você faria o seguinte código no mês de janeiro:

%let base_fatura = fatura_201601;
data extracao_campanha;
     set &base_fatura;
     if fatura > 500;
run;

Novamente, a gente declara uma variável e insere ela no código com o comando ‘&’ seguido do nome do input. No mês seguinte, você precisaria apenas trocar o valor atribuído ao %let e executar o mesmo código:

%let base_fatura = fatura_201602;
data extracao_campanha;
     set &base_fatura;
     if fatura > 500;
run;

Pense agora na quantidade de possibilidades. Deixar o valor da fatura, o nome da base de saída e outras variáveis flexíveis também. Pense agora se você tivesse 50 condições ao invés dessa única. Facilitaria bastante, não?

Dica rápida: Acrescentando zero na frente do número no SAS

Sabe aquele cpf que algum sem noção mandou em formato numérico e veio com menos de 11 dígitos na sua base?

Para deixá-lo com 11 dígitos e com zero na frente é simples, use o put() e o ‘z11.’ na sequência.

Por exemplo, você recebeu a tabela Clientes, na qual a coluna DOCUMENTO veio em formato numérico, ou seja, muitos não vão ter 11 dígitos, e você pode querer o CPF correto por diversos motivos. A conversão é simples, você utiliza um length apenas para garantir o comprimento da variável correto e manda bala no put:

data clientes_v2;
    set clientes;
    length cpf $11.;
    cpf = put(documento, z11.);
run;

Abbreviation Macro no SAS – Atalho de Códigos

Uma ferramenta bacana do SAS é o Abbreviation Macro, que serve para você salvar trechos de códigos que você utiliza constantemente. Isso economiza um bom tempo. Um exemplo clássico é para fazer os joins dos proc sql e os merge do data step, que todo mundo utiliza e às vezes dá aquele branco, ou aquela preguiça. Com o Abbreviation Macro você pode salvar um exemplo desses códigos e utilizar. É bem simples de utilizar:

1 – Vá em Program e selecione Add Abbreviation Macro:

2 – Digite um nome para o trecho que você quer chamar. No meu exemplo, é um código que eu utilizo para compactar bases no SAS e que eu nomeei COMPACTAR:

Pronto, vá no seu código, escreva COMPACTAR e veja a mágica acontecer (seu código vai aparecer lá!). Fácil assim.

O código de compactar está disponível em: Compactar e Descompactar Bases no SAS