R bibliothèques pour l'apprentissage en profondeur

Je me demandais s'il existait de bonnes bibliothèques R pour les réseaux de neurones d'apprentissage en profondeur? Je sais qu'il ya la nnet, neuralnetet RSNNS, mais aucun d' entre eux semblent mettre en œuvre des méthodes d'apprentissage en profondeur.

Je suis particulièrement intéressé par les activités non supervisées suivies par un apprentissage supervisé et l' utilisation du décrochage pour éviter la co-adaptation .

/ edit: Après quelques années, j’ai trouvé le paquet h20 deep learning très bien conçu et facile à installer. J'aime aussi le paquetage mxnet , qui est (un peu) plus difficile à installer, mais prend en charge des fonctionnalités telles que les covnets, fonctionne sur des GPU et est très rapide.

OpenSource h2o.deepLearning () est un paquet pour le développement de ressources en R de h2o.ai, voici une description http://www.r-bloggers.com/things-to-try-after-user-part-1-deep-learning- avec-h2o /

Et le code: 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

Il y a un paquet appelé "darch"

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

Citation de CRAN:

darch: Package pour les architectures profondes et les machines restreintes-Bolzmann

Le paquet darch est construit sur la base du code de GE Hinton et RR Salakhutdinov (disponible dans le code Matlab pour les réseaux de croyances profondes: dernière visite: 01.08.2013). Ce package permet de générer des réseaux de neurones à plusieurs couches (architectures profondes) et de les former à la méthode introduite par les publications "Un algorithme d'apprentissage rapide pour les réseaux de croyances profondes" (GE Hinton, S. Osindero, YW Teh) et "Réduire la dimensionnalité des données avec des réseaux de neurones "(GE Hinton, RR Salakhutdinov). Cette méthode comprend une formation préalable à la publication de la méthode de divergence par contraste de GE Hinton (2002) et une mise au point avec des algorithmes d’entraînement connus tels que la rétro-propagation ou le gradient conjugué.

Il y a un autre nouveau paquet pour les réseaux profonds dans R: deepnet

Je n'ai pas encore essayé de l'utiliser, mais il a déjà été intégré au paquet caret .

Pour répondre à ma propre question, j'ai écrit un petit paquetage dans R pour RBM: https://github.com/zachmayer/rbm

Ce paquet est encore en plein développement, et je connais très peu de RBM, alors je serais ravi de recevoir vos commentaires (et demandes de pull!). Vous pouvez installer le paquet en utilisant devtools :

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

Le code est similaire à l'implémentation d'Andrew Landgraf dans R et à l'implémentation d'Edwin Chen en python , mais j'ai écrit que la fonction était similaire à la fonction pca dans la base R et incluait une fonctionnalité d'empilage. Je pense que c'est un peu plus convivial que le paquet darch , que je ne saurais jamais utiliser (même avant sa suppression de CRAN).

Si le paquet gputools est installé, vous pouvez utiliser votre GPU pour les opérations de matrice avec la fonction rbm_gpu. Cela accélère beaucoup les choses! En outre, la majeure partie du travail dans un RBM se fait avec des opérations matricielles. Il ne suffit donc pas d’installer un bon BLAS, tel que openBLAS, pour que les choses s’éclatent .

Voici ce qui se passe lorsque vous exécutez le code sur l'exemple de jeu de données d'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

Vous pouvez essayer le module Deep Learning de H2O, il est distribué et propose de nombreuses techniques avancées telles que la régularisation des abandons et le taux d’apprentissage adaptatif.

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

Tutoriels: http://learn.h2o.ai Données et scripts: http://data.h2o.ai

Documentation: http://docs.h2o.ai GitBooks: http://gitbook.io/@h2o

Pour ajouter une autre réponse:

mxnet est incroyable, et j'adore ça. Il est un peu difficile à installer, mais il prend en charge les GPU et plusieurs processeurs. Si vous souhaitez approfondir votre connaissance de R (en particulier sur les images), je vous recommande vivement de commencer par mxnet.

Bien que je n'ai pas rencontré de bibliothèque d'apprentissage en profondeur dédiée à R, j'ai eu une discussion similaire sur les r-blogueurs. La discussion est centrée sur l'utilisation de RBM (Restricted Boltzman Machines). Jetez un coup d'œil au lien suivant--

http://www.r-bloggers.com/restricted-boltzmann-machines-in-r/ (republié à partir de 'alandgraf.blogspot.com')

L’auteur encapsule bien un algorithme auto-implémenté dans R. Il faut dire que je n’ai pas encore vérifié la validité du code, mais au moins un éclaircissement en profondeur commence à apparaître dans R.

J'espère que ça aide.

Vous pouvez maintenant aussi utiliser TensorFlow de R:

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