Bibliotecas R para aprendizaje profundo

Me preguntaba si hay buenas bibliotecas R para redes neuronales de aprendizaje profundo. Sé que está el nnet,, neuralnety RSNNS, pero ninguno de estos parece implementar métodos de aprendizaje profundo.

Estoy especialmente interesado en el aprendizaje no supervisado seguido del aprendizaje supervisado y en el uso de la deserción escolar para evitar la coadaptación .

/ editar: Después de unos años, he encontrado que el paquete de aprendizaje profundo h20 está muy bien diseñado y es fácil de instalar. También me encanta el paquete mxnet , que es (un poco) más difícil de instalar pero admite cosas como covnets, se ejecuta en GPU y es realmente rápido.

OpenSource h2o.deepLearning () es un paquete para profundizar el aprendizaje en R desde h2o.ai aquí hay un escrito http://www.r-bloggers.com/things-to-try-after-user-part-1-deep-learning- con-h2o /

Y 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

Hay un paquete llamado "darch"

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

Cita de CRAN:

darch: paquete para arquitecturas profundas y máquinas de Bolzmann restringido

El paquete darch se basa en el código de GE Hinton y RR Salakhutdinov (disponible bajo el Código Matlab para redes de creencias profundas: última visita: 01.08.2013). Este paquete es para generar redes neuronales con muchas capas (arquitecturas profundas) y entrenarlas con el método introducido por las publicaciones "Un algoritmo de aprendizaje rápido para redes de creencias profundas" (GE Hinton, S. Osindero, YW Teh) y "Reducir la dimensionalidad de datos con redes neuronales "(GE Hinton, RR Salakhutdinov). Este método incluye un entrenamiento previo con el método de divergencia contrastante publicado por GE Hinton (2002) y un ajuste fino con algoritmos de entrenamiento conocidos comunes como retropropagación o gradiente conjugado.

Hay otro nuevo paquete para redes profundas en R: deepnet

Todavía no he intentado usarlo, pero ya se ha incorporado al paquete de caret .

Para responder a mi propia pregunta, escribí un pequeño paquete en R para RBM: https://github.com/zachmayer/rbm

Este paquete aún está en desarrollo, y sé muy poco acerca de los RBM, por lo que agradecería cualquier comentario (y solicitudes de extracción) que tenga. Puede instalar el paquete usando devtools :

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

El código es similar a la implementación de Andrew Landgraf en R y la implementación de Edwin Chen en python , pero escribí que la función es similar a la función pca en la base R e incluye funcionalidad para el apilamiento. Creo que es un poco más fácil de usar que el paquete Darch , que nunca pude descubrir cómo usar (incluso antes de que fuera eliminado de CRAN).

Si tiene instalado el paquete gputools , puede usar su GPU para operaciones matriciales con la función rbm_gpu. ¡Esto acelera mucho las cosas! Además, la mayor parte del trabajo en un RBM se realiza con operaciones matriciales, por lo que solo instalar un buen BLAS, como openBLAS , también acelerará mucho las cosas.

Esto es lo que sucede cuando ejecuta el código en el conjunto de datos de ejemplo 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

Puede probar el módulo de aprendizaje profundo de H2O, se distribuye y ofrece muchas técnicas avanzadas, como la regularización de abandono y la tasa de aprendizaje adaptativo.

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

Tutoriales: http://learn.h2o.ai Datos y secuencias de comandos: http://data.h2o.ai

Documentación: http://docs.h2o.ai GitBooks: http://gitbook.io/@h2o

Para agregar otra respuesta:

mxnet es increíble, y me encanta Es un poco difícil de instalar, pero admite GPU y múltiples CPU. Si va a hacer un aprendizaje profundo en R (particularmente en imágenes), le recomiendo que comience con mxnet.

Si bien no he encontrado una biblioteca de aprendizaje profundo dedicada para R, me he encontrado con una discusión similar en r-bloggers. La discusión se centra en el uso de RBM (Restricted Boltzman Machines). Echa un vistazo al siguiente enlace:

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

El autor realmente hace un buen trabajo encapsulando un algoritmo auto implementado en R. Hay que decir que aún no he investigado la validez del código, pero al menos hay un destello de aprendizaje profundo que comienza a mostrarse en R.

Espero que esto ayude.

Ahora también puede usar TensorFlow de R:

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