Archive

Posts Tagged ‘linux’

Paralelização de Processos II

Dando continuidade ao que foi apresentado no post sobre paralelização de processos e motivado pelo comentário do colega J. Franky e fundamentalmente com a ajuda de Benilton Carvalho (aos quais deixo meu agradecimento), nesse “fast-post” vou mostrar uma outra implementação em paralelo.

O cenário é exatamente o mesmo do apresentado no post anterior (veja para entender). Agora, entretanto o processamento paralelo se dará em dois “níveis”, a saber: As nsmc simulações correm como um fork, ou seja, cópias do mesmo processo. Elas são implementadas como uma função e “correm” com a função mclapply(), o argumento mc.set.seed = TRUE garante que cada uma das nsmc terá uma semente geradora de números diferente.

Dentro de cada simualação temos ainda dois processos independentes dentro de cada ciclo (as duas estratégias de amostragem). Para um caso em que cada uma dessas estratégias demore um tempo grande, ao invés de esperar que a primeira termine para então começar a segunda, usamos uma versão de thread, com as funções parallel() e collect() e paralelizamos as duas estratégias.

O argumento mc.set.seed = TRUE tem o mesmo propósito que anteriormente, o argmento name = ‘foo’ é um grande facilitador… Vocês vão entender! Ao passar uma tarefa (a estratégia de amostragem) pela função parallel() é mesmo que dar um comando no terminal com um ‘nohup &’, ou seja, o computador executa a tarefa mas não “bloqueia” tal terminal para outro comando.

Depois de paralelizados, os processos são coletados pela função collect() na estrutura de uma lista, temos como argumentos da função (que não estão sendo usados, veja a documentação) o wait, ele é muito útil quando queremos que se espera ‘X’ tempo pelo fim das tarefas, após esse tempo, o processo continua.

A vantagem do uso do argumento name = ‘foo’ é que por default os nomes na estrutura da lista do collect recebem o número PID do processo, ao atribuir um nome fica muito mais fácil distribuir o que foi paralelizado.

Espero que tenham gostado… Lembrando que este é um exemplo puramente didático, que provavelmente não se aplica ao uso desses procedimentos. Segue portando código da terceira implementação, agora com o uso de paralelização em dois níveis.

#-----------------------------------------------------------------------------
## 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

## SEGUNDO CASO -- paralelizada
#-----------------------------------------------------------------------------
## IDEM (realiza um simulacao de 'nsmc')
simula.ii <- 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, 5000, 5)]
  resultados[2, ] <- c(mean(estrA), var(estrA), mean(estrB), var(estrB))
  for(k in 3:ciclos) {
    ## pA e pB paralelizados em 'thread'
    pA <- parallel(tipoA(estrA), name = 'A', mc.set.seed = TRUE)
    pB <- parallel(tipoB(estrB), name = 'B', mc.set.seed = TRUE)
    estrG <- collect(list(pA, pB)) # coleta dos processos paralelizados
    estrA <- estrG$A; estrB <- estrG$B # redistribui os processos
    resultados[k, ] <- c(mean(estrA), var(estrA), mean(estrB), var(estrB))
  }
  return(resultados) # retorna uma simulacao
}

tempoC <- system.time({ # armazena o tempo de processamento
saida3 <- mclapply(1:nsmc, # numero de nsmc
# aplica a funcao -- faz a simulacao
                   simula.ii,
                   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
})

## TEMPO
tempoC[3]

Até a próxima!

Usando o R para fazer downloads de arquivos

Printscreen do diretório com destaque para a seleção dos detalhes do arquivo. O conteúdo selecionado é importado para o R.

Neste link (ce223-2011-01) estão os scripts das minhas aulas de Estatística Computacional, ministradas no primeiro semestre de 2011 para o curso de Estatística da UFPR. Esse curso abordou diversos tópicos, incluindo expressões regulares, manipulação de datas, gráficos da lattice, etc. Aos interessados, é possível fazer o download arquivo por arquivo ou usar o R para automatizar tal tarefa. Isso eu vou ensinar nesse post: como fazer download de arquivos com o R (no linux).

Abra uma sessão R. Agora abra o link dos arquivos no seu navageador. Com o mouse faça a seleção das linhas contendo o nome dos arquivos. Copie para área de transferência (ctrol+c). No R você vai carregar o conteúdo copiado e armazenar em um data.frame. Isso é porque precisamos do nome dos arquivos. Juntando o nome dos arquivos ao prefixo do link, podemos fazer download usando o comando wget do linux. Faremos o R submeter todos os links para o linux baixar. Veja o CMR abaixo. Até a próxima ridícula.

#-----------------------------------------------------------------------------
# diretório web onde estão os arquivos
dire <- "http://www.leg.ufpr.br/~walmes/ensino/ce223-2011-01/"
browseURL(URLencode(dire)) # abra a página no seu navegador

#-----------------------------------------------------------------------------
# lendo a tabela com nome dos arquivos (via ctrol+c)
tab <- read.table("clipboard", header=FALSE, sep="\t", stringsAsFactors=FALSE)
str(tab)

#-----------------------------------------------------------------------------
# segunda coluna corresponde ao nome dos arquivos
arq <- tab$V2

#-----------------------------------------------------------------------------
# suponha que eu queira apenas os arquivos de extensão *.R, eles são
extR <- grep(".R$", arq, value=TRUE)

#-----------------------------------------------------------------------------
# formar o nome dos links para download, colocar o wget antes pois é o comando
links <- paste("wget ", dire, extR, sep="")
links[1]

#-----------------------------------------------------------------------------
# usar a função system() para fazer download com wget

sapply(links, system)

#-----------------------------------------------------------------------------
# pronto, todos os downloads foram feitos. Agora você pode ir na página desses
# caras sabidões e ter as notas de aulas, arquivos, seminários para poder
# aprender. Visite essas páginas:
# http://www.commanster.eu/
# http://socserv.mcmaster.ca/jfox/
# http://www.stat.wisc.edu/~bates/
# http://www.stat.missouri.edu/~ferreiram/
# http://www.isid.ac.in/~deepayan/
# http://www.math.mcmaster.ca/~bolker/
#-----------------------------------------------------------------------------
Categorias:linux Tags:, ,

Dicas para compilar Sweave no Linux

Sweave é o ponto de encontro entre o R e LaTeX. É uma ferramenta de edição de texto que combina o poder e elegância do LaTeX para edição de textos científicos com o as funcionalidades do aplicativo (mais que) estatístico R. Nesse post vamos apresentar dicas para compilar arquivos de extensão *.Rnw no terminal do Linux.

Considere que existe um arquivo mysweave.Rnw em um diretório de trabalho do seu Linux. Crie um arquivo de extensão *.sh que basicamente é um arquivo com comandos que são aplicados na linha do terminal do Linux. Use o nome swv.sh (acrônimo de sweave) e cole nele o conteúdo abaixo.

#!/bin/sh
# compila o arquivo *.Rnw gerando um *.tex
echo "library(tools); Sweave(paste(\"$1\",'.Rnw', sep=''))" | R --no-save --no-restore;
# compila o arquivo *.tex gerando um arquivo *.dvi
latex $1.tex
# compila o arquivo *.bib que contém as bibliografias
bibtex $1
# compila o arquivo *.tex gerando um arquivo *.pdf
pdflatex $1.tex

Cada comando do arquivo swv.sh contém um comentário acima da respectiva ordem que identifica a ação. O arquivo swv.sh deve estar no mesmo diretório do arquivo mysweave.Rnw e será onde os demais arquivos serão criados.

Nesse passo criaremos uma alias para o arquivo swv.sh. Para isso, vá no seu diretório pessoal (home) e edite o arquivo .bashrc (é um arquivo oculto). Adicione nesse arquivo as linhas abaixo.

# atalho para compilar *.Rnw
alias swv="./swv.sh"

Para compilar o seu arquivo mysweave.Rnw basta executar o comando swv no seu diretório de trabalho dessa forma

$ swv mysweave

Não é necessária a inclusão da extensão *.Rnw. É esperado que os respectivos arquivos mysweave.dvi e mysweave.pdf sejam gerados.

É possível definir esse atalho globalmente. Para isso, cole o arquivo swv.sh no diretório /bin. Para usar, na linha de comando faça

$ swv.sh mysweave

Dessa forma não é necessário ter o arquivo swv.sh em todo diretório com arquivos *.Rnw.

Categorias:linux, sweave Tags:, , , , ,