Librerie R per l'apprendimento profondo

Mi chiedevo se ci sono buone librerie R là fuori per le reti neurali di apprendimento profondo? So che c'è il nnet, neuralnete RSNNS, ma nessuno di questi sembra implementare metodi di apprendimento profondo.

Sono particolarmente interessato a un apprendimento non supervisionato seguito da un apprendimento supervisionato e all'utilizzo del dropout per prevenire il coadattamento .

/ modifica: dopo alcuni anni, ho trovato il pacchetto di apprendimento profondo h20 molto ben progettato e facile da installare. Adoro anche il pacchetto mxnet , che è (un po ') più difficile da installare ma supporta cose come le covnet, gira su GPU ed è molto veloce.

OpenSource h2o.deepLearning () è un pacchetto per l'apprendimento profondo in R da h2o.ai ecco un articolo di scrittura http://www.r-bloggers.com/things-to-try-after-user-part-1-deep-learning- con-H2O /

E codice: 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

C'è un pacchetto chiamato "darch"

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

Citazione da CRAN:

darch: pacchetto per architetture profonde e macchine con restrizioni di Bolzmann

Il pacchetto darch è costruito sulla base del codice di GE Hinton e RR Salakhutdinov (disponibile sotto il Codice Matlab per reti di credenze profonde: ultima visita: 01.08.2013). Questo pacchetto serve a generare reti neurali con molti livelli (architetture profonde) e ad addestrarle con il metodo introdotto dalle pubblicazioni "Un algoritmo di apprendimento rapido per reti di credenze profonde" (GE Hinton, S. Osindero, YW Teh) e "Ridurre la dimensionalità di dati con reti neurali "(GE Hinton, RR Salakhutdinov). Questo metodo include un pre-allenamento con il metodo della divergenza contrastante pubblicato da GE Hinton (2002) e una messa a punto con algoritmi di allenamento noti come backpropagation o gradiente coniugato.

C'è un altro nuovo pacchetto per reti profonde in R: deepnet

Non ho provato ad usarlo ancora, ma è già stato incorporato nel punto di inserimento pacchetto.

Per rispondere alla mia domanda, ho scritto un piccolo pacchetto in R per RBM: https://github.com/zachmayer/rbm

Questo pacchetto è ancora in fase di sviluppo, e so molto poco sugli RBM, quindi accetterei con favore qualsiasi feedback (e richieste pull!) Che hai. Puoi installare il pacchetto usando devtools :

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

Il codice è simile all'implementazione di Andrew Landgraf in R e dell'implementazione di Edwin Chen in Python , ma ho scritto che la funzione è simile alla funzione pca nella base R e include funzionalità per lo stacking. Penso che sia un po 'più user-friendly rispetto al pacchetto darch , che non sono mai riuscito a capire come usare (anche prima che fosse rimosso da CRAN).

Se hai installato il pacchetto gputools puoi usare la tua GPU per operazioni a matrice con la funzione rbm_gpu. Questo accelera molto le cose! Inoltre, la maggior parte del lavoro in un RBM è fatto con operazioni a matrice, quindi solo l'installazione di un buon BLAS, come openBLAS , velocizzerà molto le cose.

Ecco cosa succede quando si esegue il codice sul set di dati di esempio di 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

Puoi provare il modulo Deep Learning di H2O, è distribuito e offre molte tecniche avanzate come la regolarizzazione dei dropout e il tasso di apprendimento adattivo.

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

Tutorial: http://learn.h2o.ai Dati e script: http://data.h2o.ai

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

Per aggiungere un'altra risposta:

mxnet è fantastico e lo adoro È un po 'difficile da installare, ma supporta GPU e CPU multiple. Se hai intenzione di fare un apprendimento approfondito in R (in particolare sulle immagini), ti consiglio vivamente di iniziare con mxnet.

Anche se non ho incontrato una libreria di deep learning dedicata per R, mi sono imbattuto in una discussione simile su r-blogger. La discussione è incentrata sull'uso di RBM (Restricted Boltzman Machines). Dai un'occhiata al seguente link:

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

L'autore fa davvero un ottimo lavoro nell'incapsulare un algoritmo auto-implementato in R. Va detto che non ho ancora verificato la validità del codice ma almeno c'è un barlume di apprendimento profondo che inizia a mostrare in R.

Spero che questo possa essere d'aiuto.

Ora puoi anche usare TensorFlow da R:

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