Bibliotecas R para aprendizado profundo

Eu queria saber se existem boas bibliotecas R por aí para redes neurais de aprendizado profundo? Eu sei que existe o nnet,, neuralnete RSNNS, mas nenhum deles parece implementar métodos de aprendizado profundo.

Estou especialmente interessado em não supervisionado, seguido de aprendizado supervisionado e no uso da evasão para impedir a co-adaptação .

/ edit: Após alguns anos, achei o pacote de aprendizado profundo h20 muito bem projetado e fácil de instalar. Também adoro o pacote mxnet , que é (um pouco) mais difícil de instalar, mas suporta coisas como covnets, roda em GPUs e é muito rápido.

OpenSource h2o.deepLearning () é um pacote para deeplearning em R de h2o.ai, aqui está um artigo http://www.r-bloggers.com/things-to-try-after-user-part-1-deep-learning- com-h2o /

E código: https://gist.github.com/woobe/3e728e02f6cc03ab86d8#file-link_data-r

######## *Convert Breast Cancer data into H2O*
dat <- BreastCancer[, -1]  # remove the ID column
dat_h2o <- as.h2o(localH2O, dat, key = 'dat')

######## *Import MNIST CSV as H2O*
dat_h2o <- h2o.importFile(localH2O, path = ".../mnist_train.csv")

######## *Using the DNN model for predictions*
h2o_yhat_test <- h2o.predict(model, test_h2o)

######## *Converting H2O format into data frame*
df_yhat_test <- as.data.frame(h2o_yhat_test)

######## Start a local cluster with 2GB RAM
library(h2o)
localH2O = h2o.init(ip = "localhost", port = 54321, startH2O = TRUE, 
                    Xmx = '2g') 
########Execute deeplearning

model <- h2o.deeplearning( x = 2:785,  # column numbers for predictors
               y = 1,   # column number for label
               data = train_h2o, # data in H2O format
               activation = "TanhWithDropout", # or 'Tanh'
               input_dropout_ratio = 0.2, # % of inputs dropout
               hidden_dropout_ratios = c(0.5,0.5,0.5), # % for nodes dropout
               balance_classes = TRUE, 
               hidden = c(50,50,50), # three layers of 50 nodes
               epochs = 100) # max. no. of epochs

Existe um pacote chamado "darch"

http://cran.um.ac.ir/web/packages/darch/index.html

Citação do CRAN:

darch: Pacote para arquiteturas profundas e máquinas de Bolzmann restrita

O pacote darch é construído com base no código da GE Hinton e RR Salakhutdinov (disponível no Código Matlab para redes de crenças profundas: última visita: 01.08.2013). Este pacote é para gerar redes neurais com muitas camadas (arquiteturas profundas) e treiná-las com o método introduzido pelas publicações "Um algoritmo de aprendizado rápido para redes de crenças profundas" (GE Hinton, S. Osindero, YW Teh) e "Reduzindo a dimensionalidade de dados com redes neurais "(GE Hinton, RR Salakhutdinov). Esse método inclui um pré-treinamento com o método de divergência contrastiva publicado por GE Hinton (2002) e um ajuste fino com algoritmos de treinamento conhecidos comuns, como retropropagação ou gradiente conjugado.

Há outro novo pacote para redes profundas no R: deepnet

Ainda não tentei usá-lo, mas ele já foi incorporado ao pacote de intercalação .

Para responder à minha própria pergunta, escrevi um pequeno pacote no R para RBMs: https://github.com/zachmayer/rbm

Este pacote ainda está em desenvolvimento pesado, e eu sei muito pouco sobre RBMs, então gostaria de receber qualquer feedback (e solicitações de recebimento!) Que você tiver. Você pode instalar o pacote usando o devtools :

devtools:::install_github('zachmayer/rbm')
library(rbm)
?rbm
?rbm_gpu
?stacked_rbm

O código é semelhante à implementação de Andrew Landgraf na implementação de R e Edwin Chen em python , mas eu escrevi a função para ser semelhante à função pca na base R e incluir a funcionalidade de empilhamento. Eu acho que é um pouco mais amigável do que o pacote darch , que eu nunca consegui descobrir como usar (mesmo antes de ser removido do CRAN).

Se você tiver o pacote gputools instalado, poderá usar sua GPU para operações de matriz com a função rbm_gpu. Isso acelera bastante as coisas! Além disso, a maior parte do trabalho em um RBM é feita com operações de matriz, portanto, apenas a instalação de um bom BLAS, como o openBLAS , também acelerará bastante as coisas.

Aqui está o que acontece quando você executa o código no conjunto de dados de exemplo de Edwin:

set.seed(10)
print('Data from: https://github.com/echen/restricted-boltzmann-machines')
Alice <- c('Harry_Potter' = 1, Avatar = 1, 'LOTR3' = 1, Gladiator = 0, Titanic = 0, Glitter = 0) #Big SF/fantasy fan.
Bob <- c('Harry_Potter' = 1, Avatar = 0, 'LOTR3' = 1, Gladiator = 0, Titanic = 0, Glitter = 0) #SF/fantasy fan, but doesn't like Avatar.
Carol <- c('Harry_Potter' = 1, Avatar = 1, 'LOTR3' = 1, Gladiator = 0, Titanic = 0, Glitter = 0) #Big SF/fantasy fan.
David <- c('Harry_Potter' = 0, Avatar = 0, 'LOTR3' = 1, Gladiator = 1, Titanic = 1, Glitter = 0) #Big Oscar winners fan.
Eric <- c('Harry_Potter' = 0, Avatar = 0, 'LOTR3' = 1, Gladiator = 1, Titanic = 0, Glitter = 0) #Oscar winners fan, except for Titanic.
Fred <- c('Harry_Potter' = 0, Avatar = 0, 'LOTR3' = 1, Gladiator = 1, Titanic = 1, Glitter = 0) #Big Oscar winners fan.
dat <- rbind(Alice, Bob, Carol, David, Eric, Fred)

#Fit a PCA model and an RBM model
PCA <- prcomp(dat, retx=TRUE)
RBM <- rbm_gpu(dat, retx=TRUE, num_hidden=2)

#Examine the 2 models
round(PCA$rotation, 2) #PCA weights
    round(RBM$rotation, 2) #RBM weights

Você pode experimentar o módulo Deep Learning do H2O, que é distribuído e oferece muitas técnicas avançadas, como regularização de abandono e taxa de aprendizado adaptável.

Slides: http://www.slideshare.net/0xdata/h2o-deeplearning-nextml Vídeo: https://www.youtube.com/watch?v=gAKbAQu900w&feature=youtu.be

Tutoriais: http://learn.h2o.ai Dados e scripts: http://data.h2o.ai

Documentação: http://docs.h2o.ai GitBooks: http://gitbook.io/@h2o

Para adicionar outra resposta:

O mxnet é incrível e eu adoro É um pouco difícil de instalar, mas suporta GPUs e várias CPUs. Se você for aprender profundamente em R (principalmente em imagens), recomendo que você comece com mxnet.

Embora eu não tenha encontrado uma biblioteca dedicada de aprendizado profundo para o R, tive uma discussão semelhante sobre os r-blogueiros. A discussão se concentra no uso de RBM (Restricted Boltzman Machines). Dê uma olhada no seguinte link--

http://www.r-bloggers.com/restricted-boltzmann-machines-in-r/ (publicado em 'alandgraf.blogspot.com')

O autor realmente faz um bom trabalho de encapsular um algoritmo auto-implementado em R. Deve-se dizer que ainda não examinei a validade do código, mas pelo menos há um vislumbre de aprendizado profundo começando a aparecer em R.

Eu espero que isso ajude.

Agora você também pode usar o TensorFlow da R:

https://rstudio.github.io/tensorflow/