Archive

Archive for the ‘notícias’ Category

Gerando código LATEX a partir do R para tabelas e matrizes

Oi Pessoal, ai vai mais uma dica!

Sabe aquela tabela (de dados ou resultados) ou matriz imensa que sai do R e que vc precisa montar ela no latex para gerar um trabalho, artigo, poster, etc? Afff q trabalhão, né?!
Mas não esquenta tem um comandinho q faz milagre no R, mas você precisa instalar o pacote xtable e pronto!

Olha um exemplinho ai para você se deliciar!!! É show!

###—###—###—###—###
x=rnorm(10,2,2)
y=rnorm(10,4,2)
A=data.frame(x,y)

require(xtable)
xtable(A)

## outro modelo
Modelo=summary(lm(x~y))
xtable(Modelo)
###—###—###—###—###

divirtam-se!
Si

Categorias:notícias

Gamma não central (ncg v 0.1.0)

A distribuição gama incompleta não-central pode ser vista como a forma geral da distribuição \chi^2 não-central e é expressa como uma mistura de uma Poisson com a função gamma (\Gamma) incompleta.

Alguns autores propuseram aproximações para a obtenção da função gamma incompleta não-central, sem, no entanto, que os procedimentos numéricos tivessem sido implementados. Outros trabalhos apresentam métodos para a obtenção da função de distribuição gamma (\Gamma) incompleta não-central e de sua inversa, mas os códigos de suas soluções não estão disponíveis.

Para o caso particular da distribuição \chi^2 não-central, existem soluções numéricas de alta qualidade e implementações em programas como o R (família de funções *chisq(), usando-se o argumento ncp). Entretanto, um dos problemas ainda remanescentes é o da obtenção do parâmetro de não-centralidade, dados os valores da função de distribuição, de x e de \alpha, tanto para a distribuição gama (\Gamma), quanto para a \chi^2 não-central.

Neste post apresentamos o pacote (ncg) que implementa uma adaptação ao método originalmente proposto para a função \beta incompleta não-central e um outro que combina o método desses autores com o método da inversão da função de distribuição em relação ao parâmetro de não-centralidade, utilizando para isso o método de Newton-Raphson.

Maiores detalhes acerca da teoria e eficácia do implementado no pacote estão disponíveis na dissertação que serviu de cerne ao desenvolvimento do Pacote, de autoria de Izabela Regina Cardoso de Oliveira, sob orientação do Prof Dr. Daniel Furtado Ferreira, do programa de Pós-Graduação em Estatística e Experimentação Agrícola da Universidade Federal de Lavras (texto completo aqui). Detalhes do pacote, estão também disponíveis no CRAN, (acesse-o por aqui)

Para exemplificar, suponha uma v.a. Y com distribuição \chi^2 com \nu = 5 e parâmetro de não-centralidade \delta = 1. Para calcular a probabilidade acumulada em y = 4 usa-se a função pchisq(), como segue:

## install.packages('ncg')
require(ncg)

nu <- 5
y <- 4
delta <- 1

pchisq(y, nu, 1)

Como a \chi^2 não-central é um caso particular da distribuição \Gamma não-central, por meio de uma simples transformação podemos calcular a probabilidade acumulada da \chi^2, usando a função pgammanc() do pacote ncg, fazemos portanto:

alpha <- nu / 2
x <- y / 2

pgammanc(x, alpha, delta) 

A função deltagammanc() computa o parâmetro de não-centralidade da função \Gamma não-central dados os valores de x, \alpha e p. Como a \chi^2 não-central é um caso particular da \Gamma não-central, essa função também pode ser usada para obter o parâmetro de não-centralidade de uma \chi^2 não-central.

deltagammanc(x, alpha, 0.3471897)

Espero que tanto o pacote, quanto as breves explicações aqui ditas sejam úteis. Agradeço aos colegas que estiveram envolvidos, Izabela e Prof Daniel, obrigado!

Fuzzy c-means, um exemplo!

Pois bem, por sugestão do Professor Julio da Motta Singer apresentarei um script para realizar uma análise de agrupamento no escopo da lógica fuzzy. Seja um experimento fatorial (a mesma natureza dos dados aqui disponibilizados) a seguinte implementação realiza a clusterização de uma dado fator marginalmente ao outro fator.

A heurística da lógica fuzzy tem um incremento interpretativo de, ao contrário do agrupamento k-means, que é dicotômico, associar a cada cluster uma “probabilidade” de associação. Todavia, no método arbitramos uma constante (m) de fuzzyficação. Assim o seguinte script realiza o agrupamento fuzzy (por intermédio da função cmeans() da biblioteca e1071) para vários valores m assim é possível observar o comportamento (decaimento) do erro associado a clusterização e também a disposição dos fatores em relação ao cluster.

Infelizmente (ou para alegria geral) não vou me atrever a discorrer da teoria envolvida nessa análise e um estudo específico deixo a cargo dos maiores interessados.

Todo esse mise en cene, me soa um pouco genérico demais, eu sei (–Me desculpem!). Mas acredito que o script possa ser útil de alguma forma.

Aproveito o ensejo para agradecer as sugestões do Prof Julio da Motta Singer ao trabalho e o incentivo a esse post. Também deixo um alô ao colegas que participaram, de uma forma ou de outra!

Vamos ao trabalho, primeiro instalando (para quem ainda não o fez) e carregando a biblioteca e o conjunto de dados!

## install.packages('e1071')
library(e1071) # carrega pacote com implementação 'c-means'

dados <- transform(read.table("http://dl.dropbox.com/u/38195533/fac_exemplo.txt", # arquivo
                              header = TRUE,
                              sep = '\t',
                              na.string = '.',
                              dec = ','),
                   fatorA = factor(fatorA),
                   fatorB = factor(fatorB))

str(dados)

ajuste <- lm(resp ~ fatorA + fatorB, data = dados)
anova(ajuste) # ANOVA

matriz <- tapply(dados$resp, list(dados$fatorB, dados$fatorA), mean)

A primeira etapa foi realizada. Não posso passar ou próximo trecho sem deixa-los a par do quem está por vir! O agrupamento que “tentamos” é com relação ao um padrão de comportamento do fator sob análise, em relação ao outro fator, assim constituímos ideótipos e assim procedemos. O modo como constituimos esses ideótipos é aplicado unicamente a natureza desse conjunto de dados, mas outros ideótipos, ao seu critério podem ser usados, fique a vontade!

Antes de passarmos agora a análise em si manipulamos os dados e constituímos os centróides:

FinWil <- apply(matriz, 2, mean) - mean(matriz) # Finlay & Wilkinson

altos <- which(FinWil >= 0) # ambientes acima da media
baixo <- which(FinWil < 0) # ambientes abaixo da media

medias <- cbind(apply(matriz[, altos], 1, mean),
                apply(matriz[, baixo], 1, mean))

##--------------------------------------------------------------------
## IDEOTIPOS
## I   - maximo em todos 
## II  - maximo nos altos minimo nos baixos
## III - minimo nos altos maximo nos baixos
## IV  - minimo em todos 
## ADICIONAIS:
## V   - media em todos
## VI  - maximo nos altos e media nos baixos
## VII  - media nos altos maximo nos baixos

I <- c(max(matriz[, altos]), max(matriz[, baixo]))
II <- c(max(matriz[, altos]), min(matriz[, baixo]))
III <- c(min(matriz[, altos]), max(matriz[, baixo]))
IV <- c(min(matriz[, altos]), min(matriz[, baixo]))
V <- c(mean(matriz[, altos]), mean(matriz[, baixo]))
VI <- c(max(matriz[, altos]), mean(matriz[, baixo]))
VII <- c(mean(matriz[, altos]), max(matriz[, baixo]))

centroides <- rbind(I, II, III, IV, V, VI, VII) # centróides

Resta agora realizar a análise em si, veja que o laço for() repete a análise para vários valores da constante m e de cada uma, armazena as “probabilidades” de associação a cada centróide e o erro do ajustamento!


ms <- seq(1.2, 10, by = .1)
lista <- array(NA, dim = c(nlevels(dados$fatorB), 
                           nrow(centroides), 
                           length(ms)))
erros <- matrix(NA, nrow = length(ms), ncol = 1)
dimnames(lista) <- list(levels(dados$TRAT), 
                        c('I', 'II', 'III', 'IV', 'V', 'VI', 'VII'), 
                        ms)

for(i in 1:length(ms))
  {
    j <- ms[i]
    ## função de cluster 'fuzzy c-means'
    grupamentos <- cmeans(medias, # matriz dos dados
                          centroides, # centróides dos clusters
                          verbose = FALSE, # não imprime histórico
                          dist = 'euclidean', # distância empregada
                          m = j, # constante de desfuzzyficação
                          method = 'cmeans') # método
    lista[,,i] <- grupamentos$membership
    erros[i,] <- grupamentos$withinerror
  }

Pronto… feito, quer dizer, quase! Realizamos portanto a análise para os vários valores de m resta agora “escolher” um deles e partir para o resto! Até a próxima…

Paralelização de processos

Hoje em dia os computadores estão cada vez mais rápidos e via de regra, nossos processsadores tem mais de um núcleo de processamento. Isso é um “horizonte” grande que nos permite avançar num campo “baixo nível” da informática de gerenciar nossos processos para que eles sejam feitos em paralelo entre os vários núcleos do processador. Esse procedimento tem recomendações bem específicas e portanto não tem reflexos gerais em qualquer aplicação.

Estou tentando aprender sobre isso e ultimamente andei lendo e brincando com esses procedimentos que estão disponíveis no R. Basicamente existem três tipos de paralilazação. As de baixo nível, que envolvem um profundo conhecimento do hardware e assim como li, não são tão recomendadas para usuários finais. Outras são as paralizações explícitas em que o usuário é quem “manda” e por fim, já está disponível no R (exceto plataforma Windows) pacotes em que é possível implementar o processo de paralelização implícita, em que o usuário interage com ferramentas internas de “baixo nível” e o computador faz o resto… (brincadeira).

No primeiro tipo, se esse for seu propósito veja a documentação dos pacotes multicore (funções fork() e children()). No segundo caso procure sobre o pacote snow. E no último caso, ao qual vou dar mais atenção, veja sobre os pacotes doMC e multiocore especificamente nas funções mclapply(), parallel() e collect().

Como exemplo vou apresentar um caso bem tosco por sinal, mas acho que bastante ilustrativo. A primeira parte do código é uma implementação bem naive de uma simulação em que sobre uma população são retiradas dois tipos de amostra, para esses dois casos são em sequencia em um certo número de ciclos retiradas amostras. Esse processo por sua vez é repetido nsmc vezes (abreviatura de numero de simulações de Monte Carlo). Para as duas implementações (a naive e a paralela) é armazenado o tempo de processamento. Veja a diferença… Se você quiser ver a coisa acontecendo, abra o capô do seu computador, no terminal digite top, vai abrir o gerenciador de processos, e você vai conseguir ver no caso da implementação em paralelo, as várias cópias do seu processo correndo, diferentemente da implementação naive em que cada simulação só começa quando a anterios acaba.

Segue o código

#-----------------------------------------------------------------------------
## PARAMETROS DA SIMULAÇÃO -- usar os mesmo para as duas situações
n <- 5000 # numero de individuos
ciclos <- 30 # numero de ciclos
nsmc <- 100 # numero de simulacoes

## PRIMEIRO CASO -- "naive"
#-----------------------------------------------------------------------------
saida1 <- vector('list', length = nsmc) # saida da implementacao SIMPLES
tempoA <- system.time({ # armazena o tempo de processamento
   for(i in 1:nsmc) { # laço -- para cada simulacao
   resultados <- matrix(NA, ciclos, 4) # matriz dos resultados individuais
   # populacao inicial
   p0 <- sample(c(0, 1, 2), n, replace = TRUE, prob = c(.25, .5, .25))
   resultados[1, ] <- rep(c(mean(p0), var(p0)), times = 2) # resultado ciclo 0
   estrA <- sample(p0, n/5, replace = FALSE) # estrategia A
   estrB <- p0[seq(1, n, 5)] # estrategia B
   # resultados ciclo 1
   resultados[2, ] <- c(mean(estrA), var(estrA), mean(estrB), var(estrB))
   for(k in 3:ciclos) { # laço -- ciclos subsequentes
      ## populacao estrategia A ciclo n
      pA <- sample(estrA, n, replace = TRUE)
      estrA <- sample(p0, n/5, replace = FALSE)
      ## populacao estrategia B ciclo n
      pB <- sample(estrB, n, replace = TRUE)
      estrB <- pB[seq(1, n, 5)]
      # resultados ciclo n
      resultados[k, ] <- c(mean(estrA), var(estrA), mean(estrB), var(estrB))
   }
   saida1[[i]] <- resultados # armazena na saida
}
})

## SEGUNDO CASO -- paralelizada
#-----------------------------------------------------------------------------
## IDEM (realiza um simulacao de 'nsmc')
simula.i <- function(x) { # inicio da funcao -- sem argumentos
   ## mesmos comentarios do caso acima
   resultados <- matrix(NA, ciclos, 4)
   p0 <- sample(c(0, 1, 2), n, replace = TRUE, prob = c(.25, .5, .25))
   resultados[1, ] <- rep(c(mean(p0), var(p0)), times = 2)
   estrA <- sample(p0, n/5, replace = FALSE)
   estrB <- p0[seq(1, n, 5)]
   resultados[2, ] <- c(mean(estrA), var(estrA), mean(estrB), var(estrB))
   for(k in 3:ciclos) {
      pA <- sample(estrA, n, replace = TRUE)
      estrA <- sample(p0, n/5, replace = FALSE)
      pB <- sample(estrB, n, replace = TRUE)
      estrB <- pB[seq(1, n, 5)]
      resultados[k, ] <- c(mean(estrA), var(estrA), mean(estrB), var(estrB))
   }
   return(resultados) # retorna uma simulacao
}

tempoB <- system.time({ # armazena o tempo de processamento
saida2 <- mclapply(1:nsmc, # numero de nsmc
# aplica a funcao -- faz a simulacao
                   simula.i,
                   mc.preschedule = FALSE,
                   # 'expande' quantos processos forem possiveis
                   mc.set.seed = TRUE,
                   # uma semente para cada processo
                   mc.cores = getOption('cores'))
                   # usa quantos processadores forem possiveis
})

## TEMPOS
tempoA[3]
tempoB[3]

Vale lembrar que é preciso estar usando ou Linux, ou Mac e é preciso antes fazer o download e chamar o pacote “multicore”. Espero que tenham gostado e que com esse exemplo consigam realizar suas próprias paraleilazações.

Categorias:linux, notícias, testes

Realçador de código R para blogs

Quem trabalha com programação reconhece que a organização do código facilita muito a releitura e checagem. O R, uma vez que é uma linguagem, possui editores que apresentam recursos para organização do código, como Emacs, RStudio, Tinn-R, Rkward entre diversos. A maioria dos editores apresenta um padrão de identação do código e realçador (highlighter) de texto. A necessidade de divulgação de código R, de forma organizada e atraente, fez com que os realçadores aparecessem nas páginas de blogs, wikis, etc. O wordpress.com possui um realçador de código R nativo. Para quem não tem wordpress.com, pode usar o Pretty R syntax highlighter que possui, além dos realces usuais, links para as páginas de documentação das funções. Abaixo está código R com o realçador do wordpress.com e com o pretty-R. Perceba que as funções (negrito azul) possuem links para página de ajuda.

# importa dados
soja <- read.table("http://www.leg.ufpr.br/~walmes/cursoR/soja.txt",
                   header=TRUE, sep="\t", dec=",")
str(soja)
 
# ajusta um modelo e pede anova
m1 <- aov(rengrao~bloco+agua*potassio, soja)
anova(m1)
 
# cria uma lista com as variáveis resposta
respostas <- do.call(c, apply(soja[,4:7], 2, list))
do.call(c, respostas)
 
# faz o ajuste para todas as respostas
ajustes <- lapply(respostas,
                  function(r){
                    m0 <- aov(r~bloco+agua*potassio, data=soja)
                    m0
                  })
 
# pede todas as anovas
lapply(ajustes, anova)
# importa dados
soja <- read.table("http://www.leg.ufpr.br/~walmes/cursoR/soja.txt",
                   header=TRUE, sep="\t", dec=",")
str(soja)
 
# ajusta um modelo e pede anova
m1 <- aov(rengrao~bloco+agua*potassio, soja)
anova(m1)
 
# cria uma lista com as variáveis resposta
respostas <- do.call(c, apply(soja[,4:7], 2, list))
do.call(c, respostas)
 
# faz o ajuste para todas as respostas
ajustes <- lapply(respostas,
                  function(r){
                    m0 <- aov(r~bloco+agua*potassio, data=soja)
                    m0
                  })
 
# pede todas as anovas
lapply(ajustes, anova)

Created by Pretty R at inside-R.org

Além de no R você fazer praticamente tudo, você pode apresentar de forma elegante. Até a próxima ridícula.

Mesclar células na linha em uma tabela no latex!

Bom dia pessoal!!

Quem nunca se perguntou como mesclar células na linha em uma tabela utilizando o latex. Eu mesmo descobri isso hoje. Mesclar células na coluna todo mundo já sabe, basta usar “\multcolumn”. Agora, para mesclar células na linha são outros quinhentos. Segue o script abaixo:

…
\usepackage{multirow}
…

\begin{tabular}{|l|l|l|}
\hline
\multicolumn{3}{|c|}{Team sheet} \\
\hline
Goalkeeper & GK & Paul Robinson \\ \hline
\multirow{4}{*}{Defenders} & LB & Lucus Radebe \\
& DC & Michael Duberry \\
& DC & Dominic Matteo \\
& RB & Didier Domi \\ \hline
\multirow{3}{*}{Midfielders} & MC & David Batty \\
& MC & Eirik Bakke \\
& MC & Jody Morris \\ \hline
Forward & FW & Jamie McMaster \\ \hline
\multirow{2}{*}{Strikers} & ST & Alan Smith \\
& ST & Mark Viduka \\
\hline
\end{tabular}

Este exemplo foi copiado do site:http://en.wikibooks.org/wiki/LaTeX/Tables. Consulte-o para muitos outros exemplos úteis.

Abraços!

Categorias:notícias

Super busca no R

Pessoal,  deixo aqui uma super ridicula! rs

Depois de muito estudar, sabe aquelas horas em que sentamos na frente do pc para começar a tão desejada análise, por exemplo, que acabamos de estudar, mas não sabemos nem por onde começar…

Ou então,  aquela perguntinha de praxe: Será que já existe alguma função ou pacote pronto do R , que faz este tipo de análise?

Então gente, existe um pacotinho do R, chamado ‘sos’,  que é mágico!  risos

Vejamos, vamos supor que eu queira pesquisar sobre uma determinada técnica ou método no R,  por exemplo, análise de componentes principais.  Entretanto, não tenho a mínima  idéia se existe função ou pacote sobre esse assunto no R. Procedam da seguinte maneira:

 _ Instale o pacote ‘sos’.  Em seguida, execute as linhas de comando:

>  require(sos)
>  ???”principal  components analysis

 E pronto!

Detalhe, tem link e tudo!

Contudo, de um modo simplificado e pesquisando apenas nos pacotes já instalados no seu pc, você pode substituir o:

???

por

help.search()

 divirtam-se!

Categorias:notícias