├── DESCRIPTION
├── MD5
├── NAMESPACE
├── R
    ├── dbn_dnn_train.R
    ├── dbn_train.R
    ├── load_mnist.R
    ├── nn_predict.R
    ├── nn_train.R
    ├── rbm_train.R
    ├── sae_dnn_train.R
    ├── sae_train.R
    └── sigm.R
└── man
    ├── dbn.dnn.train.Rd
    ├── load.mnist.Rd
    ├── nn.predict.Rd
    ├── nn.test.Rd
    ├── nn.train.Rd
    ├── rbm.down.Rd
    ├── rbm.train.Rd
    ├── rbm.up.Rd
    └── sae.dnn.train.Rd


/DESCRIPTION:
--------------------------------------------------------------------------------
 1 | Package: deepnet
 2 | Type: Package
 3 | Title: Deep Learning Toolkit in R
 4 | Version: 0.2.1
 5 | Date: 2014-03-20
 6 | Author: Xiao Rong
 7 | Maintainer: Xiao Rong <runxiao@gmail.com>
 8 | Description: Implement some deep learning architectures and neural network
 9 |     algorithms, including BP,RBM,DBN,Deep autoencoder and so on.
10 | License: GPL
11 | Packaged: 2022-06-24 12:10:21 UTC; hornik
12 | NeedsCompilation: no
13 | Repository: CRAN
14 | Date/Publication: 2022-06-24 12:29:27 UTC
15 | 


--------------------------------------------------------------------------------
/MD5:
--------------------------------------------------------------------------------
 1 | e85570803253722bb5ae3f98cf92a909 *DESCRIPTION
 2 | 22ac7b5f35e19598c995817ce9c94dc4 *NAMESPACE
 3 | 94de9b8fdb88addceab762d029422434 *R/dbn_dnn_train.R
 4 | 322102ab3dff32139813dc7f64f82e25 *R/dbn_train.R
 5 | edb1672f0cedad2fb3dfce53527b6ee3 *R/load_mnist.R
 6 | ce9a3cdc72c7af5ab1d98b22a00760b4 *R/nn_predict.R
 7 | de9d52a596f6b662f6792f8dd42c14a0 *R/nn_train.R
 8 | 835c1bd192212d37f5164609461583b3 *R/rbm_train.R
 9 | 15dedb2cf455a8549f66986033bc9e6d *R/sae_dnn_train.R
10 | 54c9b1c08214146f6c29f798264495e7 *R/sae_train.R
11 | 40584cbe9b87e055ac2bd97ab14331e9 *R/sigm.R
12 | 2b6e47563d1b8baa2ced3beee263b318 *man/dbn.dnn.train.Rd
13 | 7ab6a22b74679ff072d7875478265605 *man/load.mnist.Rd
14 | 621730e7d6268dd4b86550c60114c0a1 *man/nn.predict.Rd
15 | cbce25a4fa1add3ae8efd2f2e4955b16 *man/nn.test.Rd
16 | fbd172f68b22f70ab60e139d1c631a14 *man/nn.train.Rd
17 | 40fe5f99305c4361d2054ca05355ec3e *man/rbm.down.Rd
18 | 01e3c59c0c41429a09d53afa5df57be8 *man/rbm.train.Rd
19 | fd33a563ac39802729a501222cad9ada *man/rbm.up.Rd
20 | fecb025d7d8c9f109b4338aefed14284 *man/sae.dnn.train.Rd
21 | 


--------------------------------------------------------------------------------
/NAMESPACE:
--------------------------------------------------------------------------------
 1 | export(dbn.dnn.train)
 2 | export(load.mnist)
 3 | export(nn.predict)
 4 | export(nn.test)
 5 | export(nn.train)
 6 | export(rbm.down)
 7 | export(rbm.train)
 8 | export(rbm.up)
 9 | export(sae.dnn.train)
10 | 
11 | importFrom("grDevices", "gray")
12 | importFrom("graphics", "image")
13 | importFrom("stats", "runif")
14 | 


--------------------------------------------------------------------------------
/R/dbn_dnn_train.R:
--------------------------------------------------------------------------------
 1 | ##' Training a Deep neural network with weights initialized by DBN
 2 | ##'
 3 | ##' Training a Deep neural network with weights initialized by DBN
 4 | ##' @param x matrix of x values for examples
 5 | ##' @param y vector or matrix of target values for examples
 6 | ##' @param hidden vector for number of units of hidden layers.Default is c(10).
 7 | ##' @param activationfun activation function of hidden unit.Can be "sigm","linear" or "tanh".Default is "sigm" for logistic function
 8 | ##' @param learningrate learning rate for gradient descent. Default is 0.8.
 9 | ##' @param momentum momentum for gradient descent. Default is 0.5 .
10 | ##' @param learningrate_scale  learning rate will be mutiplied by this scale after every iteration. Default is 1 .
11 | ##' @param numepochs number of iteration for samples  Default is 3.
12 | ##' @param batchsize size of mini-batch. Default is 100.
13 | ##' @param output function of output unit, can be "sigm","linear" or "softmax". Default is "sigm".
14 | ##' @param hidden_dropout drop out fraction for hidden layer. Default is 0.
15 | ##' @param visible_dropout drop out fraction for input layer Default is 0.
16 | ##' @param cd number of iteration for Gibbs sample of CD algorithm.
17 | ##' @author Xiao Rong
18 | ##' @examples
19 | ##' Var1 <- c(rnorm(50,1,0.5),rnorm(50,-0.6,0.2))
20 | ##' Var2 <- c(rnorm(50,-0.8,0.2),rnorm(50,2,1))
21 | ##' x <- matrix(c(Var1,Var2),nrow=100,ncol=2)
22 | ##' y <- c(rep(1,50),rep(0,50))
23 | ##' dnn <-dbn.dnn.train(x,y,hidden=c(5,5))
24 | ##' ## predict by dnn
25 | ##' test_Var1 <- c(rnorm(50,1,0.5),rnorm(50,-0.6,0.2))
26 | ##' test_Var2 <- c(rnorm(50,-0.8,0.2),rnorm(50,2,1))
27 | ##' test_x <- matrix(c(test_Var1,test_Var2),nrow=100,ncol=2)
28 | ##' nn.test(dnn,test_x,y)
29 | ##' @export
30 | dbn.dnn.train <- function(x,y,hidden=c(1),
31 |                           activationfun="sigm",
32 |                           learningrate=0.8,
33 |                           momentum=0.5,
34 |                           learningrate_scale=1,
35 |                           output="sigm",
36 |                           numepochs=3,batchsize=100,
37 |                           hidden_dropout=0,visible_dropout=0,cd=1){
38 |   
39 |   output_dim <- 0
40 |   if(is.vector(y)){
41 |     output_dim <- 1
42 |   }else if(is.matrix(y)){
43 |     output_dim <- ncol(y)
44 |   }
45 |   if (output_dim == 0) 
46 |     stop("y must be a vector or matrix!")
47 |   message("begin to train dbn ......")
48 |   dbn <- dbn.train(x,hidden=hidden,
49 |                    numepochs=numepochs,batchsize=batchsize,
50 |                    learningrate=learningrate,learningrate_scale=learningrate_scale,
51 |                    momentum=momentum,cd=cd)
52 |   message("dbn has been trained.")
53 |   initW <- list()
54 |   initB <- list()
55 |   for(i in 1:(length(dbn$size) - 1)){
56 |     initW[[i]] <- dbn$rbm[[i]]$W   
57 |     initB[[i]] <- dbn$rbm[[i]]$C   
58 |   }
59 |   #random init weight between last hidden layer and output layer
60 |   last_hidden <- dbn$size[length(dbn$size)]
61 |   initW[[length(dbn$size)]] <- matrix(runif(output_dim*last_hidden,min=-0.1,max=0.1), c(output_dim,last_hidden))
62 |   initB[[length(dbn$size)]] <- runif(output_dim,min=-0.1,max=0.1)
63 |   message("begin to train deep nn ......")
64 |   dnn <- nn.train(x,y,initW=initW,initB=initB,hidden=hidden,
65 |                   activationfun=activationfun,
66 |                   learningrate=learningrate,
67 |                   momentum=momentum,
68 |                   learningrate_scale=learningrate_scale,
69 |                   output=output,
70 |                   numepochs=numepochs,batchsize=batchsize,
71 |                   hidden_dropout=0,visible_dropout=0)
72 |   message("deep nn has been trained.")
73 |   dnn
74 | }


--------------------------------------------------------------------------------
/R/dbn_train.R:
--------------------------------------------------------------------------------
 1 | dbn.train <- function(x,hidden=c(10,10),
 2 |                       numepochs=3,batchsize=100,
 3 |                       learningrate=0.8,learningrate_scale=1,momentum=0.5,
 4 |                       visible_type="bin",hidden_type="bin",cd=1){
 5 |   if (!is.matrix(x)) 
 6 |     stop("x must be a matrix!")
 7 |   input_dim <- ncol(x)  
 8 |   dbn <- list(
 9 |     size = c(input_dim, hidden)
10 |   )
11 |   train_x <- x
12 |   message("training layer 1 rbm ...")
13 |   dbn$rbm[[1]] <- rbm.train(train_x,hidden[1],
14 |                             numepochs=numepochs,batchsize=batchsize,
15 |                             learningrate=learningrate,learningrate_scale=learningrate_scale,
16 |                             momentum=momentum,
17 |                             visible_type=visible_type,hidden_type=hidden_type,cd=cd)
18 |   
19 |   if(length(dbn$size) > 2){
20 |     for(i in 2:(length(dbn$size) - 1)){
21 |       train_x <- rbm.up(dbn$rbm[[i-1]], train_x)  
22 |       message(sprintf("training layer %d rbm ...",i))
23 |       dbn$rbm[[i]] <- rbm.train(train_x,hidden[i],
24 |                                 numepochs=numepochs,batchsize=batchsize,
25 |                                 learningrate=learningrate,learningrate_scale=learningrate_scale,
26 |                                 momentum=momentum,
27 |                                 visible_type=visible_type,hidden_type=hidden_type,cd=cd)
28 |     }
29 |   }
30 |   dbn
31 | }
32 | 
33 | dbn.down <- function(dbn,h,round=10){
34 |   hi <- h
35 |   i <- length(dbn$size) - 1 #top rbm
36 |   for(j in 1:round){
37 |     vi <- rbm.down(dbn$rbm[[i]],hi)
38 |     hi <- rbm.up(dbn$rbm[[i]],vi)
39 |   }
40 |   if(length(dbn$size) > 2){
41 |     hi <- vi
42 |     for(i in (length(dbn$size) - 2):1){
43 |       vi <- rbm.down(dbn$rbm[[i]],hi)
44 |       hi <- vi
45 |     }    
46 |   }
47 |   vi
48 | }
49 | 


--------------------------------------------------------------------------------
/R/load_mnist.R:
--------------------------------------------------------------------------------
 1 | ##' Load MNIST DataSet
 2 | ##'
 3 | ##' Load MNIST DataSet
 4 | ##' @param dir dir of minst dataset
 5 | ##' @return mnist dataset
 6 | ##'   train$n   number of train samples
 7 | ##'   train$x   pix of every train sample image
 8 | ##'   train$y   label of every train sample image
 9 | ##'   train$yy  one-of-c vector of label of train sample image
10 | ##'   test$n   number of test samples
11 | ##'   test$x   pix of every test sample image
12 | ##'   test$y   label of every test sample image
13 | ##'   test$yy  one-of-c vector of label of test sample image
14 | ##' @author Xiao Rong
15 | ##' @export
16 | load.mnist <- function(dir) {
17 |   load.image.file <- function(filename) {
18 |     ret <- list()
19 |     f <- file(filename,'rb')
20 |     readBin(f,'integer',n=1,size=4,endian='big')
21 |     ret$n <- readBin(f,'integer',n=1,size=4,endian='big')
22 |     nrow <- readBin(f,'integer',n=1,size=4,endian='big')
23 |     ncol <- readBin(f,'integer',n=1,size=4,endian='big')
24 |     x <- readBin(f,'integer',n=ret$n*nrow*ncol,size=1,signed=F)
25 |     ret$x <- matrix(x, ncol=nrow*ncol, byrow=T)
26 |     close(f)
27 |     ret
28 |   }
29 |   load.label.file <- function(filename) {
30 |     f = file(filename,'rb')
31 |     readBin(f,'integer',n=1,size=4,endian='big')
32 |     n = readBin(f,'integer',n=1,size=4,endian='big')
33 |     y = readBin(f,'integer',n=n,size=1,signed=F)
34 |     close(f)
35 |     y
36 |   }
37 |   mnist <- list()
38 |   mnist$train <- load.image.file(paste(dir,'/train-images-idx3-ubyte',sep=""))
39 |   mnist$test <- load.image.file(paste(dir,'/t10k-images-idx3-ubyte',sep=""))
40 |   
41 |   mnist$train$y <- load.label.file(paste(dir,'/train-labels-idx1-ubyte',sep=""))
42 |   n <- length(mnist$train$y)
43 |   mnist$train$yy <- matrix(rep(0,n*10),nrow=n,ncol=10)
44 |   for (i in 1:n){
45 |     mnist$train$yy[i,mnist$train$y[i] + 1] <- 1
46 |   }
47 |   mnist$test$y <- load.label.file(paste(dir,'/t10k-labels-idx1-ubyte',sep=""))
48 |   m <- length(mnist$test$y)
49 |   mnist$test$yy <- matrix(rep(0,m*10),nrow=m,ncol=10)
50 |   for (j in 1:m){
51 |     mnist$test$yy[j,mnist$test$y[j] + 1] <- 1
52 |   }
53 |   mnist
54 | }
55 | 
56 | 
57 | show.digit <- function(arr784, col=gray(12:1/12), ...) {
58 |   image(matrix(arr784, nrow=28)[,28:1], col=col, ...)
59 | }


--------------------------------------------------------------------------------
/R/nn_predict.R:
--------------------------------------------------------------------------------
 1 | ##' Predict new samples by Trainded NN
 2 | ##'
 3 | ##' Predict new samples by Trainded NN
 4 | ##' @param nn nerual network trained by function nn.train
 5 | ##' @param x new samples to predict
 6 | ##' @return return raw output value of neural network.For classification task,return the probability of a class
 7 | ##' @examples
 8 | ##' Var1 <- c(rnorm(50,1,0.5),rnorm(50,-0.6,0.2))
 9 | ##' Var2 <- c(rnorm(50,-0.8,0.2),rnorm(50,2,1))
10 | ##' x <- matrix(c(Var1,Var2),nrow=100,ncol=2)
11 | ##' y <- c(rep(1,50),rep(0,50))
12 | ##' nn <-nn.train(x,y,hidden=c(5))
13 | ##' ## predict by nn
14 | ##' test_Var1 <- c(rnorm(50,1,0.5),rnorm(50,-0.6,0.2))
15 | ##' test_Var2 <- c(rnorm(50,-0.8,0.2),rnorm(50,2,1))
16 | ##' test_x <- matrix(c(test_Var1,test_Var2),nrow=100,ncol=2)
17 | ##' yy <- nn.predict(nn,test_x)
18 | ##' 
19 | ##' @author Xiao Rong
20 | ##' @export
21 | 
22 | nn.predict <- function(nn,x){
23 |   m <- nrow(x)
24 |   post <- x
25 |   #hidden layer
26 |   for(i in 2:(length(nn$size) - 1)){
27 |     pre <- t( nn$W[[i-1]] %*% t(post) + nn$B[[i-1]] )
28 |     if(nn$activationfun == "sigm"){
29 |       post <- sigm( pre )
30 |     }else if(nn$activationfun == "tanh"){
31 |       post <- tanh(pre)
32 |     }else{
33 |       stop("unsupport activation function 'nn$activationfun'");
34 |     }	
35 |     post <- post * (1 - nn$hidden_dropout)
36 |   }
37 |   #output layer
38 |   i <- length(nn$size)
39 |   pre <- t( nn$W[[i-1]] %*% t(post) + nn$B[[i-1]] )
40 |   if(nn$output == "sigm"){
41 |     post <- sigm( pre )
42 |   }else if(nn$output == "linear"){
43 |     post <- pre  
44 |   }else if(nn$output == "softmax"){
45 |     post <- exp(pre)
46 |     post <- post / rowSums(post) 
47 |   }	else{
48 |     stop("unsupport output function!");
49 |   }	
50 |   post
51 | }
52 | 
53 | ##' Test new samples by Trainded NN
54 | ##'
55 | ##' Test new samples by Trainded NN,return error rate for classification
56 | ##' @param nn nerual network trained by function nn.train
57 | ##' @param x new samples to predict
58 | ##' @param y new samples' label
59 | ##' @param t threshold for classification. If nn.predict value >= t then label 1,else label 0
60 | ##' @return error rate
61 | ##' @examples
62 | ##' Var1 <- c(rnorm(50,1,0.5),rnorm(50,-0.6,0.2))
63 | ##' Var2 <- c(rnorm(50,-0.8,0.2),rnorm(50,2,1))
64 | ##' x <- matrix(c(Var1,Var2),nrow=100,ncol=2)
65 | ##' y <- c(rep(1,50),rep(0,50))
66 | ##' nn <-nn.train(x,y,hidden=c(5))
67 | ##' test_Var1 <- c(rnorm(50,1,0.5),rnorm(50,-0.6,0.2))
68 | ##' test_Var2 <- c(rnorm(50,-0.8,0.2),rnorm(50,2,1))
69 | ##' test_x <- matrix(c(test_Var1,test_Var2),nrow=100,ncol=2)
70 | ##' err <- nn.test(nn,test_x,y)
71 | ##' 
72 | ##' @author Xiao Rong
73 | ##' @export
74 | nn.test <- function (nn,x,y,t=0.5){
75 |   y_p <- nn.predict(nn,x)
76 |   m <- nrow(x)
77 |   y_p[y_p>=t] <- 1
78 |   y_p[y_p<t] <- 0
79 |   error_count <- sum(abs( y_p - y)) / 2
80 |   error_count / m
81 | }


--------------------------------------------------------------------------------
/R/nn_train.R:
--------------------------------------------------------------------------------
  1 | ##' Training Neural Network
  2 | ##'
  3 | ##' Training single or mutiple hidden layers neural network by BP 
  4 | ##' @param x matrix of x values for examples
  5 | ##' @param y vector or matrix of target values for examples
  6 | ##' @param initW initial weights. If missing chosen at random 
  7 | ##' @param initB initial bias. If missing chosen at random 
  8 | ##' @param hidden vector for number of units of hidden layers.Default is c(10).
  9 | ##' @param activationfun activation function of hidden unit.Can be "sigm","linear" or "tanh".Default is "sigm" for logistic function
 10 | ##' @param learningrate learning rate for gradient descent. Default is 0.8.
 11 | ##' @param momentum momentum for gradient descent. Default is 0.5 .
 12 | ##' @param learningrate_scale  learning rate will be mutiplied by this scale after every iteration. Default is 1 .
 13 | ##' @param numepochs number of iteration for samples  Default is 3.
 14 | ##' @param batchsize size of mini-batch. Default is 100.
 15 | ##' @param output function of output unit, can be "sigm","linear" or "softmax". Default is "sigm".
 16 | ##' @param hidden_dropout drop out fraction for hidden layer. Default is 0.
 17 | ##' @param visible_dropout drop out fraction for input layer Default is 0.
 18 | ##' @examples
 19 | ##' Var1 <- c(rnorm(50,1,0.5),rnorm(50,-0.6,0.2))
 20 | ##' Var2 <- c(rnorm(50,-0.8,0.2),rnorm(50,2,1))
 21 | ##' x <- matrix(c(Var1,Var2),nrow=100,ncol=2)
 22 | ##' y <- c(rep(1,50),rep(0,50))
 23 | ##' nn <-nn.train(x,y,hidden=c(5))
 24 | ##' @author Xiao Rong
 25 | ##' @export
 26 | nn.train <- function(x,y,initW=NULL,initB=NULL,hidden=c(10),
 27 |                     activationfun="sigm",
 28 |                     learningrate=0.8,
 29 |                     momentum=0.5,
 30 |                     learningrate_scale=1,
 31 |                     output="sigm",
 32 | 										numepochs=3,batchsize=100,
 33 |                     hidden_dropout=0,visible_dropout=0) {
 34 | 	if (!is.matrix(x)) 
 35 |      stop("x must be a matrix!")
 36 | 	input_dim <- ncol(x)
 37 | 	output_dim <- 0;
 38 | 	if(is.vector(y)){
 39 | 		output_dim <- 1
 40 | 	}else if(is.matrix(y)){
 41 | 		output_dim <- ncol(y)
 42 | 	}
 43 | 	if (output_dim == 0) 
 44 |         stop("y must be a vector or matrix!")
 45 | 	size <- c(input_dim, hidden, output_dim)
 46 | 	vW <- list() 
 47 |   vB <- list()
 48 |   if(is.null(initW) || is.null(initB)){
 49 | 	  W <- list()
 50 |   	B <- list()
 51 | 	  #random init weights and bias between layers							 
 52 | 	  for( i in 2:length(size) ){
 53 | 		  W[[i-1]] <- matrix(runif(size[i]*size[i-1],min=-0.1,max=0.1), c(size[i],size[i-1]));
 54 | 		  B[[i-1]] <- runif(size[i],min=--0.1,max=0.1);
 55 | 		  vW[[i-1]] <- matrix(rep(0,size[i]*size[i-1]),c(size[i],size[i-1]))
 56 |       vB[[i-1]] <- rep(0,size[i])
 57 | 	  }
 58 |   }else{
 59 |     W <- initW
 60 |     B <- initB
 61 |     for( i in 2:length(size) ){
 62 |       vW[[i-1]] <- matrix(rep(0,size[i]*size[i-1]),c(size[i],size[i-1]))
 63 |       vB[[i-1]] <- rep(0,size[i])
 64 |       if(nrow(W[[i-1]]) != size[i] || ncol(W[[i-1]]) != size[i-1] ){
 65 |         stop("init W size is not eq to network size!")  
 66 |       }    
 67 |       if(length(B[[i-1]]) != size[i]){
 68 |         stop("init B size is not eq to network size!")  
 69 |       }
 70 |     }
 71 |   }
 72 | 	
 73 | 	nn <- list(
 74 | 		input_dim = input_dim,
 75 | 		output_dim = output_dim,
 76 | 		hidden = hidden,
 77 | 		size = size,
 78 | 		activationfun = activationfun,
 79 | 		learningrate = learningrate,
 80 | 		momentum = momentum,
 81 | 		learningrate_scale = learningrate_scale,
 82 | 		hidden_dropout=hidden_dropout,visible_dropout=visible_dropout,
 83 | 		output = output,
 84 | 		W = W,
 85 | 		vW = vW,
 86 | 		B = B,
 87 |     vB = vB
 88 | 	)
 89 | 	
 90 | 	m <- nrow(x);
 91 | 	numbatches <- m / batchsize;
 92 | 	s <- 0
 93 | 	for(i in 1:numepochs){
 94 | 		randperm <- sample(1:m,m)
 95 | 		if(numbatches >= 1){
 96 | 			for(l in 1 : numbatches){
 97 | 			  s <- s + 1
 98 | 				batch_x <- x[randperm[((l-1)*batchsize+1):(l*batchsize)], ] 
 99 | 				if(is.vector(y)){
100 | 					batch_y <- y[randperm[((l-1)*batchsize+1):(l*batchsize)]] 
101 | 				}else if(is.matrix(y)){
102 | 					batch_y <- y[randperm[((l-1)*batchsize+1):(l*batchsize)], ] 
103 | 				}
104 | 				
105 | 				nn <- nn.ff(nn,batch_x,batch_y,s)
106 | 				nn <- nn.bp(nn)						
107 | 			}
108 | 		}
109 | 		#last fraction of sample
110 | 		if(numbatches > as.integer(numbatches)){
111 | 			batch_x <- x[randperm[(as.integer(numbatches)*batchsize):m], ]
112 | 			if(is.vector(y)){
113 | 				batch_y <- y[randperm[(as.integer(numbatches)*batchsize):m]]
114 | 			}else if(is.matrix(y)){
115 | 				batch_y <- y[randperm[(as.integer(numbatches)*batchsize):m], ]
116 | 			}
117 | 			s <- s + 1
118 | 			nn <- nn.ff(nn,batch_x,batch_y,s)
119 | 			nn <- nn.bp(nn)	
120 | 		}
121 | 			
122 | 		nn$learningrate <- nn$learningrate * nn$learningrate_scale;
123 | 	}
124 | 	
125 | 	nn
126 | }
127 | 
128 | nn.ff <- function(nn,batch_x,batch_y,s){
129 |   m <- nrow(batch_x)
130 |   #do input dropout
131 |   if(nn$visible_dropout > 0){
132 |     nn$dropout_mask[[1]] <- dropout.mask(ncol(batch_x),nn$visible_dropout)
133 |     batch_x <- t( t(batch_x) * nn$dropout_mask[[1]] )
134 |   }
135 | 	nn$post[[1]] <- batch_x
136 | 	for(i in 2:(length(nn$size) - 1)){
137 | 	  nn$pre[[i]] <- t( nn$W[[i-1]] %*% t(nn$post[[(i-1)]])  + nn$B[[i-1]] )
138 | 		if(nn$activationfun == "sigm"){
139 | 			nn$post[[i]] <- sigm(nn$pre[[i]])
140 | 		}else if(nn$activationfun == "tanh"){
141 | 			nn$post[[i]] <- tanh(nn$pre[[i]])
142 | 		}else{
143 | 			stop("unsupport activation function!");
144 | 		}	
145 |     if(nn$hidden_dropout > 0){
146 |       nn$dropout_mask[[i]] <- dropout.mask(ncol(nn$post[[i]]),nn$hidden_dropout)
147 |       nn$post[[i]] <- t( t(nn$post[[i]]) * nn$dropout_mask[[i]] )
148 |     }
149 | 	}
150 | 	#output layer
151 | 	i <- length(nn$size)
152 |   nn$pre[[i]] <- t( nn$W[[i-1]] %*% t(nn$post[[(i-1)]])  + nn$B[[i-1]] )
153 | 	if(nn$output == "sigm"){
154 | 		nn$post[[i]] <- sigm(nn$pre[[i]])
155 | 		nn$e <- batch_y - nn$post[[i]]
156 | 		nn$L[ s ] <- 0.5*sum(nn$e^2)/m
157 | 	}else if(nn$output == "linear"){
158 | 	  nn$post[[i]] <- nn$pre[[i]]
159 | 	  nn$e <- batch_y - nn$post[[i]]
160 | 	  nn$L[ s ] <- 0.5*sum(nn$e^2)/m
161 | 	}else if(nn$output == "softmax"){
162 | 	  nn$post[[i]] <- exp(nn$pre[[i]])
163 | 	  nn$post[[i]] <- nn$post[[i]] / rowSums(nn$post[[i]]) 
164 | 	  nn$e <- batch_y - nn$post[[i]]
165 | 	  nn$L[ s ] <- -sum(batch_y * log(nn$post[[i]]))/m
166 | 	}else{
167 | 	  stop("unsupport output function!");
168 | 	}	
169 |   if(s %% 10000 == 0){
170 |     message(sprintf("####loss on step %d is : %f",s,nn$L[ s ]))
171 |   }
172 | 	
173 | 	nn
174 | }
175 | 
176 | 
177 | nn.bp <- function(nn){
178 | 	n <- length(nn$size)
179 |   d <- list()
180 | 	if(nn$output == "sigm"){
181 | 		d[[n]] <- -nn$e * (nn$post[[n]] * (1 - nn$post[[n]]))
182 | 	}else if(nn$output == "linear" || nn$output == "softmax"){
183 | 		d[[n]] <- -nn$e
184 | 	}
185 | 
186 | 	for( i in (n-1):2 ){
187 | 			if(nn$activationfun  == "sigm"){
188 | 				d_act <- nn$post[[i]] * (1-nn$post[[i]])
189 | 			}else if(nn$activationfun  == "tanh" ){
190 | 				d_act <- 1.7159 * 2/3 * (1 - 1/(1.7159)^2 * nn$post[[i]]^2)
191 | 			}
192 | 			d[[i]] <- (d[[i+1]] %*% nn$W[[i]]) * d_act
193 | 			if(nn$hidden_dropout > 0){
194 | 			  d[[i]] <- t( t(d[[i]]) * nn$dropout_mask[[i]] )
195 | 			}
196 | 	}
197 | 	
198 | 	for( i in 1:(n-1) ){
199 | 			dw <- t(d[[i+1]]) %*% nn$post[[i]] / nrow(d[[i+1]])
200 | 			dw <- dw * nn$learningrate
201 | 			if(nn$momentum > 0){
202 | 				nn$vW[[i]] <- nn$momentum * nn$vW[[i]] + dw
203 | 				dw <- nn$vW[[i]]
204 | 			}
205 | 			nn$W[[i]] <- nn$W[[i]] - dw
206 | 			
207 | 			db <- colMeans(d[[i+1]])
208 | 			db <- db * nn$learningrate
209 | 			if(nn$momentum > 0){
210 | 			  nn$vB[[i]] <- nn$momentum * nn$vB[[i]] + db
211 | 			  db <- nn$vB[[i]]
212 | 			}
213 | 			nn$B[[i]] <- nn$B[[i]] - db
214 | 	}
215 | 	nn
216 | }
217 | 
218 | dropout.mask <- function(size,fraction){
219 |   mask <- runif(size,min=0,max=1)
220 |   mask[mask <= fraction] <- 0
221 |   mask[mask > fraction] <- 1
222 |   mask
223 | }
224 | 


--------------------------------------------------------------------------------
/R/rbm_train.R:
--------------------------------------------------------------------------------
  1 | ##' Training a RBM(restricted Boltzmann Machine)
  2 | ##'
  3 | ##' Training a RBM(restricted Boltzmann Machine)
  4 | ##' @param x matrix of x values for examples
  5 | ##' @param hidden number of hidden units
  6 | ##' @param visible_type activation function of input unit.Only support "sigm" now
  7 | ##' @param hidden_type activation function of hidden unit.Only support "sigm" now
  8 | ##' @param learningrate learning rate for gradient descent. Default is 0.8.
  9 | ##' @param momentum momentum for gradient descent. Default is 0.5 .
 10 | ##' @param learningrate_scale  learning rate will be mutiplied by this scale after every iteration. Default is 1 .
 11 | ##' @param numepochs number of iteration for samples  Default is 3.
 12 | ##' @param batchsize size of mini-batch. Default is 100.
 13 | ##' @param cd number of iteration for Gibbs sample of CD algorithm.
 14 | ##' @examples
 15 | ##' Var1 <- c(rep(1,50),rep(0,50))
 16 | ##' Var2 <- c(rep(0,50),rep(1,50))
 17 | ##' x3 <- matrix(c(Var1,Var2),nrow=100,ncol=2)
 18 | ##' r1 <- rbm.train(x3,10,numepochs=20,cd=10)
 19 | ##' @author Xiao Rong
 20 | ##' @export
 21 | rbm.train <- function(x,hidden,
 22 |                       numepochs=3,batchsize=100,
 23 |                       learningrate=0.8,learningrate_scale=1,momentum=0.5,
 24 |                       visible_type="bin",hidden_type="bin",cd=1){
 25 |   
 26 |   if (!is.matrix(x)) 
 27 |     stop("x must be a matrix!")
 28 |   input_dim <- ncol(x)
 29 |   
 30 |   rbm <- list(
 31 |       size = c(input_dim, hidden),
 32 |       W = matrix(runif(hidden*input_dim,min=-0.1,max=0.1), c(hidden,input_dim)),
 33 |       vW = matrix(rep(0,hidden*input_dim), c(hidden,input_dim)),
 34 |       B = runif(input_dim,min=-0.1,max=0.1),
 35 |       vB = rep(0,input_dim),
 36 |       C = runif(hidden,min=-0.1,max=0.1),
 37 |       vC = rep(0,hidden),
 38 |       learningrate = learningrate,
 39 |       learningrate_scale = learningrate_scale,
 40 |       momentum = momentum,
 41 |       hidden_type = hidden_type, visible_type = visible_type,
 42 |       cd=cd
 43 |     )
 44 |   m <- nrow(x);
 45 |   numbatches <- m / batchsize;
 46 |   s <- 0
 47 |   for(i in 1:numepochs){
 48 |     randperm <- sample(1:m,m)
 49 |     if(numbatches >= 1){
 50 |       for(l in 1 : numbatches){
 51 |         s <- s + 1
 52 |         batch_x <- x[randperm[((l-1)*batchsize+1):(l*batchsize)], ] 
 53 |         rbm <- do.rbm.train(rbm,batch_x,s)
 54 |       }
 55 |     }
 56 |     #last fraction of sample
 57 |     if(numbatches > as.integer(numbatches)){
 58 |       batch_x <- x[randperm[(as.integer(numbatches)*batchsize):m], ]      
 59 |       s <- s + 1
 60 |       rbm <- do.rbm.train(rbm,batch_x,s)
 61 |     }
 62 |     
 63 |     rbm$learningrate <- rbm$learningrate * rbm$learningrate_scale;
 64 |   }
 65 |   
 66 |   rbm
 67 | }
 68 | 
 69 | do.rbm.train <- function(rbm,batch_x,s){
 70 |   m <- nrow(batch_x)
 71 |   v1 <- batch_x
 72 |   h1 <- binary.state(rbm.up(rbm, v1))
 73 | 
 74 |   vn <- v1
 75 |   hn <- h1
 76 |   for(i in 1:rbm$cd){
 77 |     vn <- rbm.down(rbm, hn)
 78 |     hn <- rbm.up(rbm, vn)  
 79 |     #only last hidden state use probability real value
 80 |     if(i < rbm$cd){
 81 |       hn <- binary.state(hn);
 82 |     }
 83 |   }
 84 |   
 85 |   
 86 |   dW <- (t(h1) %*% v1 - t(hn)  %*% vn) / m
 87 |   dW <- rbm$learningrate * dW
 88 |   rbm$vW <- rbm$vW * rbm$momentum + dW
 89 |   dw <- rbm$vW
 90 |   rbm$W <- rbm$W + dW
 91 |   
 92 |   dB <- colMeans(v1 - vn)
 93 |   dB <- rbm$learningrate * dB
 94 |   rbm$vB <- rbm$vB * rbm$momentum + dB
 95 |   dB <- rbm$vB
 96 |   rbm$B <- rbm$B + dB
 97 |   
 98 |   dC <- colMeans(h1 - hn) 
 99 |   dC <- rbm$learningrate * dC
100 |   rbm$vC <- rbm$vC * rbm$momentum + dC
101 |   dC <- rbm$vC
102 |   rbm$C <- rbm$C + dC
103 |   
104 |   rbm$e[s] <- sum((v1 - vn)^2)/m
105 |   rbm
106 | }
107 | 
108 | 
109 | ##' Infer hidden units state by visible units
110 | ##'
111 | ##' Infer hidden units states by visible units
112 | ##' @param rbm an rbm object trained by function train.rbm
113 | ##' @param v visible units states
114 | ##' @return hidden units states
115 | ##' @examples
116 | ##' Var1 <- c(rep(1,50),rep(0,50))
117 | ##' Var2 <- c(rep(0,50),rep(1,50))
118 | ##' x3 <- matrix(c(Var1,Var2),nrow=100,ncol=2)
119 | ##' r1 <- rbm.train(x3,3,numepochs=20,cd=10)
120 | ##' v <- c(0.2,0.8)
121 | ##' h <- rbm.up(r1,v)
122 | ##' @author Xiao Rong
123 | ##' @export
124 | rbm.up <- function(rbm,v){
125 |   m <- nrow(v)
126 |   if(rbm$hidden_type == "bin"){
127 |     sum <- t( t(v %*% t(rbm$W)) + rbm$C )
128 |     h <- sigm( sum )
129 |   }else{
130 |     stop("only support binary state for rbm hidden layer!")
131 |   }  
132 |   h
133 | }
134 | 
135 | ##' Generate visible vector by hidden units states
136 | ##'
137 | ##' Generate visible vector by hidden units states
138 | ##' @param rbm an rbm object trained by function train.rbm
139 | ##' @param h hidden units states
140 | ##' @return generated visible vector
141 | ##' @examples
142 | ##' Var1 <- c(rep(1,50),rep(0,50))
143 | ##' Var2 <- c(rep(0,50),rep(1,50))
144 | ##' x3 <- matrix(c(Var1,Var2),nrow=100,ncol=2)
145 | ##' r1 <- rbm.train(x3,3,numepochs=20,cd=10)
146 | ##' h <- c(0.2,0.8,0.1)
147 | ##' v <- rbm.down(r1,h)
148 | ##' @author Xiao Rong
149 | ##' @export
150 | rbm.down <- function(rbm,h){
151 |   m <- nrow(h)
152 |   if(rbm$visible_type == "bin"){
153 |     sum <- t( t(h %*% rbm$W) + rbm$B )
154 |     v <- sigm( sum )
155 |   }else{
156 |     stop("only support binary state for rbm hidden layer!")
157 |   } 
158 |   v
159 | }
160 | 
161 | binary.state <- function(h){
162 |   p <- matrix( runif(length(h),min=0,max=1)
163 |                ,nrow=nrow(h),ncol=ncol(h))
164 |   h[h>p] <- 1
165 |   h[h<=p] <- 0
166 |   h
167 | }


--------------------------------------------------------------------------------
/R/sae_dnn_train.R:
--------------------------------------------------------------------------------
 1 | ##' Training a Deep neural network with weights initialized by Stacked AutoEncoder
 2 | ##'
 3 | ##' Training a Deep neural network with weights initialized by Stacked AutoEncoder
 4 | ##' @param x matrix of x values for examples
 5 | ##' @param y vector or matrix of target values for examples
 6 | ##' @param hidden vector for number of units of hidden layers.Default is c(10).
 7 | ##' @param activationfun activation function of hidden unit.Can be "sigm","linear" or "tanh".Default is "sigm" for logistic function
 8 | ##' @param learningrate learning rate for gradient descent. Default is 0.8.
 9 | ##' @param momentum momentum for gradient descent. Default is 0.5 .
10 | ##' @param learningrate_scale  learning rate will be mutiplied by this scale after every iteration. Default is 1 .
11 | ##' @param numepochs number of iteration for samples  Default is 3.
12 | ##' @param batchsize size of mini-batch. Default is 100.
13 | ##' @param output function of output unit, can be "sigm","linear" or "softmax". Default is "sigm".
14 | ##' @param sae_output function of autoencoder output unit, can be "sigm","linear" or "softmax". Default is "linear".
15 | ##' @param hidden_dropout drop out fraction for hidden layer. Default is 0.
16 | ##' @param visible_dropout drop out fraction for input layer Default is 0.
17 | ##' @examples
18 | ##' Var1 <- c(rnorm(50,1,0.5),rnorm(50,-0.6,0.2))
19 | ##' Var2 <- c(rnorm(50,-0.8,0.2),rnorm(50,2,1))
20 | ##' x <- matrix(c(Var1,Var2),nrow=100,ncol=2)
21 | ##' y <- c(rep(1,50),rep(0,50))
22 | ##' dnn <-sae.dnn.train(x,y,hidden=c(5,5))
23 | ##' ## predict by dnn
24 | ##' test_Var1 <- c(rnorm(50,1,0.5),rnorm(50,-0.6,0.2))
25 | ##' test_Var2 <- c(rnorm(50,-0.8,0.2),rnorm(50,2,1))
26 | ##' test_x <- matrix(c(test_Var1,test_Var2),nrow=100,ncol=2)
27 | ##' nn.test(dnn,test_x,y)
28 | ##' @author Xiao Rong
29 | ##' @export
30 | sae.dnn.train <- function(x,y,hidden=c(1),
31 |                           activationfun="sigm",
32 |                           learningrate=0.8,
33 |                           momentum=0.5,
34 |                           learningrate_scale=1,
35 |                           output="sigm",
36 |                           sae_output="linear",
37 |                           numepochs=3,batchsize=100,
38 |                           hidden_dropout=0,visible_dropout=0){
39 |   output_dim <- 0
40 |   if(is.vector(y)){
41 |     output_dim <- 1
42 |   }else if(is.matrix(y)){
43 |     output_dim <- ncol(y)
44 |   }
45 |   if (output_dim == 0) 
46 |     stop("y must be a vector or matrix!")
47 |   message("begin to train sae ......")
48 |   sae <- sae.train(x,hidden=hidden,
49 |                    activationfun=activationfun,
50 |                    output=sae_output,
51 |                    numepochs=numepochs,batchsize=batchsize,
52 |                    learningrate=learningrate,learningrate_scale=learningrate_scale,
53 |                    momentum=momentum,
54 |                    hidden_dropout=hidden_dropout,visible_dropout=visible_dropout)
55 |   message("sae has been trained.")
56 |   initW <- list()
57 |   initB <- list()
58 |   for(i in 1:(length(sae$size) - 1)){
59 |     initW[[i]] <- sae$encoder[[i]]$W[[1]]   
60 |     initB[[i]] <- sae$encoder[[i]]$B[[1]]  
61 |   }
62 |   #random init weights between last hidden layer and output layer
63 |   last_hidden <- sae$size[length(sae$size)]
64 |   initW[[length(sae$size)]] <- matrix(runif(output_dim*last_hidden,min=-0.1,max=0.1), c(output_dim,last_hidden))
65 |   initB[[length(sae$size)]] <- runif(output_dim,min=-0.1,max=0.1)
66 |   message("begin to train deep nn ......")
67 |   dnn <- nn.train(x,y,initW=initW,initB=initB,hidden=hidden,
68 |                   activationfun=activationfun,
69 |                   learningrate=learningrate,
70 |                   momentum=momentum,
71 |                   learningrate_scale=learningrate_scale,
72 |                   output=output,
73 |                   numepochs=numepochs,batchsize=batchsize,
74 |                   hidden_dropout=hidden_dropout,visible_dropout=visible_dropout)
75 |   message("deep nn has been trained.")
76 |   dnn
77 | }


--------------------------------------------------------------------------------
/R/sae_train.R:
--------------------------------------------------------------------------------
 1 | sae.train <- function(x,hidden=c(10),
 2 |                       activationfun="sigm",
 3 |                       learningrate=0.8,
 4 |                       momentum=0.5,
 5 |                       learningrate_scale=1,
 6 |                       output="sigm",
 7 |                       numepochs=3,batchsize=100,
 8 |                       hidden_dropout=0,visible_dropout=0.2                      
 9 |                       ){
10 |   if (!is.matrix(x)) 
11 |     stop("x must be a matrix!")
12 |   input_dim <- ncol(x)
13 |   size <- c(input_dim, hidden)
14 |   sae <- list(
15 |     input_dim = input_dim,
16 |     hidden = hidden,
17 |     size = size
18 |   )
19 |   train_x <- x
20 |   message(sprintf("training layer 1 autoencoder ..."))
21 |   sae$encoder[[1]] <-  nn.train(train_x,train_x,hidden=c(hidden[1]),
22 |                                       activationfun=activationfun,
23 |                                       learningrate=learningrate,
24 |                                       momentum=momentum,
25 |                                       learningrate_scale=learningrate_scale,
26 |                                       output=output,
27 |                                       numepochs=numepochs,batchsize=batchsize,
28 |                                       hidden_dropout=hidden_dropout,visible_dropout=visible_dropout)
29 |   
30 |   if(length(sae$size) > 2){
31 |     for(i in 2:(length(sae$size) - 1)){
32 |       pre <- t( sae$encoder[[i-1]]$W[[1]] %*% t(train_x) + sae$encoder[[i-1]]$B[[i-1]] )
33 |       if(sae$encoder[[i-1]]$activationfun == "sigm"){
34 |         post <- sigm( pre )
35 |       }else if(sae$encoder[[i-1]]$activationfun == "tanh"){
36 |         post <- tanh(pre)
37 |       }else{
38 |         stop("unsupport activation function 'nn$activationfun'");
39 |       }  
40 |       train_x <- post
41 |       message(sprintf("training layer %d autoencoder ...",i))
42 |       sae$encoder[[i]] <- nn.train(train_x,train_x,hidden=c(hidden[i]),
43 |                                    activationfun=activationfun,
44 |                                    learningrate=learningrate,
45 |                                    momentum=momentum,
46 |                                    learningrate_scale=learningrate_scale,
47 |                                    output=output,
48 |                                    numepochs=numepochs,batchsize=batchsize,
49 |                                    hidden_dropout=hidden_dropout,visible_dropout=visible_dropout)
50 |     }
51 |   }
52 |   sae
53 | }
54 | 
55 | 
56 | 


--------------------------------------------------------------------------------
/R/sigm.R:
--------------------------------------------------------------------------------
1 | sigm <- function(x){
2 |   1/(1+exp(-x))
3 | }


--------------------------------------------------------------------------------
/man/dbn.dnn.train.Rd:
--------------------------------------------------------------------------------
 1 | \name{dbn.dnn.train}
 2 | \alias{dbn.dnn.train}
 3 | \title{Training a Deep neural network with weights initialized by DBN}
 4 | \usage{
 5 | dbn.dnn.train(x, y, hidden = c(1), activationfun = "sigm", learningrate = 0.8, 
 6 |     momentum = 0.5, learningrate_scale = 1, output = "sigm", numepochs = 3, 
 7 |     batchsize = 100, hidden_dropout = 0, visible_dropout = 0, cd = 1)
 8 | }
 9 | \arguments{
10 |   \item{x}{matrix of x values for examples}
11 | 
12 |   \item{y}{vector or matrix of target values for examples}
13 | 
14 |   \item{hidden}{vector for number of units of hidden
15 |   layers.Default is c(10).}
16 | 
17 |   \item{activationfun}{activation function of hidden
18 |   unit.Can be "sigm","linear" or "tanh".Default is "sigm"
19 |   for logistic function}
20 | 
21 |   \item{learningrate}{learning rate for gradient descent.
22 |   Default is 0.8.}
23 | 
24 |   \item{momentum}{momentum for gradient descent. Default is
25 |   0.5 .}
26 | 
27 |   \item{learningrate_scale}{learning rate will be mutiplied
28 |   by this scale after every iteration. Default is 1 .}
29 | 
30 |   \item{numepochs}{number of iteration for samples Default
31 |   is 3.}
32 | 
33 |   \item{batchsize}{size of mini-batch. Default is 100.}
34 | 
35 |   \item{output}{function of output unit, can be
36 |   "sigm","linear" or "softmax". Default is "sigm".}
37 | 
38 |   \item{hidden_dropout}{drop out fraction for hidden layer.
39 |   Default is 0.}
40 | 
41 |   \item{visible_dropout}{drop out fraction for input layer
42 |   Default is 0.}
43 | 
44 |   \item{cd}{number of iteration for Gibbs sample of CD
45 |   algorithm.}
46 | }
47 | \description{
48 | Training a Deep neural network with weights initialized by
49 | DBN
50 | }
51 | \examples{
52 | Var1 <- c(rnorm(50, 1, 0.5), rnorm(50, -0.6, 0.2))
53 | Var2 <- c(rnorm(50, -0.8, 0.2), rnorm(50, 2, 1))
54 | x <- matrix(c(Var1, Var2), nrow = 100, ncol = 2)
55 | y <- c(rep(1, 50), rep(0, 50))
56 | dnn <- dbn.dnn.train(x, y, hidden = c(5, 5))
57 | ## predict by dnn
58 | test_Var1 <- c(rnorm(50, 1, 0.5), rnorm(50, -0.6, 0.2))
59 | test_Var2 <- c(rnorm(50, -0.8, 0.2), rnorm(50, 2, 1))
60 | test_x <- matrix(c(test_Var1, test_Var2), nrow = 100, ncol = 2)
61 | nn.test(dnn, test_x, y)
62 | }
63 | \author{
64 | Xiao Rong
65 | }
66 | 


--------------------------------------------------------------------------------
/man/load.mnist.Rd:
--------------------------------------------------------------------------------
 1 | \name{load.mnist}
 2 | \alias{load.mnist}
 3 | \title{Load MNIST DataSet}
 4 | \usage{
 5 | load.mnist(dir)
 6 | }
 7 | \arguments{
 8 |   \item{dir}{dir of minst dataset}
 9 | }
10 | \value{
11 | mnist dataset train$n number of train samples train$x pix
12 | of every train sample image train$y label of every train
13 | sample image train$yy one-of-c vector of label of train
14 | sample image test$n number of test samples test$x pix of
15 | every test sample image test$y label of every test sample
16 | image test$yy one-of-c vector of label of test sample image
17 | }
18 | \description{
19 | Load MNIST DataSet
20 | }
21 | \author{
22 | Xiao Rong
23 | }
24 | 


--------------------------------------------------------------------------------
/man/nn.predict.Rd:
--------------------------------------------------------------------------------
 1 | \name{nn.predict}
 2 | \alias{nn.predict}
 3 | \title{Predict new samples by Trainded NN}
 4 | \usage{
 5 | nn.predict(nn, x)
 6 | }
 7 | \arguments{
 8 |   \item{nn}{nerual network trained by function nn.train}
 9 | 
10 |   \item{x}{new samples to predict}
11 | }
12 | \value{
13 | return raw output value of neural network.For
14 | classification task,return the probability of a class
15 | }
16 | \description{
17 | Predict new samples by Trainded NN
18 | }
19 | \examples{
20 | Var1 <- c(rnorm(50, 1, 0.5), rnorm(50, -0.6, 0.2))
21 | Var2 <- c(rnorm(50, -0.8, 0.2), rnorm(50, 2, 1))
22 | x <- matrix(c(Var1, Var2), nrow = 100, ncol = 2)
23 | y <- c(rep(1, 50), rep(0, 50))
24 | nn <- nn.train(x, y, hidden = c(5))
25 | ## predict by nn
26 | test_Var1 <- c(rnorm(50, 1, 0.5), rnorm(50, -0.6, 0.2))
27 | test_Var2 <- c(rnorm(50, -0.8, 0.2), rnorm(50, 2, 1))
28 | test_x <- matrix(c(test_Var1, test_Var2), nrow = 100, ncol = 2)
29 | yy <- nn.predict(nn, test_x)
30 | }
31 | \author{
32 | Xiao Rong
33 | }
34 | 


--------------------------------------------------------------------------------
/man/nn.test.Rd:
--------------------------------------------------------------------------------
 1 | \name{nn.test}
 2 | \alias{nn.test}
 3 | \title{Test new samples by Trainded NN}
 4 | \usage{
 5 | nn.test(nn, x, y, t = 0.5)
 6 | }
 7 | \arguments{
 8 |   \item{nn}{nerual network trained by function nn.train}
 9 | 
10 |   \item{x}{new samples to predict}
11 | 
12 |   \item{y}{new samples' label}
13 | 
14 |   \item{t}{threshold for classification. If nn.predict
15 |   value >= t then label 1,else label 0}
16 | }
17 | \value{
18 | error rate
19 | }
20 | \description{
21 | Test new samples by Trainded NN,return error rate for
22 | classification
23 | }
24 | \examples{
25 | Var1 <- c(rnorm(50, 1, 0.5), rnorm(50, -0.6, 0.2))
26 | Var2 <- c(rnorm(50, -0.8, 0.2), rnorm(50, 2, 1))
27 | x <- matrix(c(Var1, Var2), nrow = 100, ncol = 2)
28 | y <- c(rep(1, 50), rep(0, 50))
29 | nn <- nn.train(x, y, hidden = c(5))
30 | test_Var1 <- c(rnorm(50, 1, 0.5), rnorm(50, -0.6, 0.2))
31 | test_Var2 <- c(rnorm(50, -0.8, 0.2), rnorm(50, 2, 1))
32 | test_x <- matrix(c(test_Var1, test_Var2), nrow = 100, ncol = 2)
33 | err <- nn.test(nn, test_x, y)
34 | }
35 | \author{
36 | Xiao Rong
37 | }
38 | 


--------------------------------------------------------------------------------
/man/nn.train.Rd:
--------------------------------------------------------------------------------
 1 | \name{nn.train}
 2 | \alias{nn.train}
 3 | \title{Training Neural Network}
 4 | \usage{
 5 | nn.train(x, y, initW = NULL, initB = NULL, hidden = c(10), activationfun = "sigm", 
 6 |     learningrate = 0.8, momentum = 0.5, learningrate_scale = 1, output = "sigm", 
 7 |     numepochs = 3, batchsize = 100, hidden_dropout = 0, visible_dropout = 0)
 8 | }
 9 | \arguments{
10 |   \item{x}{matrix of x values for examples}
11 | 
12 |   \item{y}{vector or matrix of target values for examples}
13 | 
14 |   \item{initW}{initial weights. If missing chosen at
15 |   random}
16 | 
17 |   \item{initB}{initial bias. If missing chosen at random}
18 | 
19 |   \item{hidden}{vector for number of units of hidden
20 |   layers.Default is c(10).}
21 | 
22 |   \item{activationfun}{activation function of hidden
23 |   unit.Can be "sigm","linear" or "tanh".Default is "sigm"
24 |   for logistic function}
25 | 
26 |   \item{learningrate}{learning rate for gradient descent.
27 |   Default is 0.8.}
28 | 
29 |   \item{momentum}{momentum for gradient descent. Default is
30 |   0.5 .}
31 | 
32 |   \item{learningrate_scale}{learning rate will be mutiplied
33 |   by this scale after every iteration. Default is 1 .}
34 | 
35 |   \item{numepochs}{number of iteration for samples Default
36 |   is 3.}
37 | 
38 |   \item{batchsize}{size of mini-batch. Default is 100.}
39 | 
40 |   \item{output}{function of output unit, can be
41 |   "sigm","linear" or "softmax". Default is "sigm".}
42 | 
43 |   \item{hidden_dropout}{drop out fraction for hidden layer.
44 |   Default is 0.}
45 | 
46 |   \item{visible_dropout}{drop out fraction for input layer
47 |   Default is 0.}
48 | }
49 | \description{
50 | Training single or mutiple hidden layers neural network by
51 | BP
52 | }
53 | \examples{
54 | Var1 <- c(rnorm(50, 1, 0.5), rnorm(50, -0.6, 0.2))
55 | Var2 <- c(rnorm(50, -0.8, 0.2), rnorm(50, 2, 1))
56 | x <- matrix(c(Var1, Var2), nrow = 100, ncol = 2)
57 | y <- c(rep(1, 50), rep(0, 50))
58 | nn <- nn.train(x, y, hidden = c(5))
59 | }
60 | \author{
61 | Xiao Rong
62 | }
63 | 


--------------------------------------------------------------------------------
/man/rbm.down.Rd:
--------------------------------------------------------------------------------
 1 | \name{rbm.down}
 2 | \alias{rbm.down}
 3 | \title{Generate visible vector by hidden units states}
 4 | \usage{
 5 | rbm.down(rbm, h)
 6 | }
 7 | \arguments{
 8 |   \item{rbm}{an rbm object trained by function train.rbm}
 9 | 
10 |   \item{h}{hidden units states}
11 | }
12 | \value{
13 | generated visible vector
14 | }
15 | \description{
16 | Generate visible vector by hidden units states
17 | }
18 | \examples{
19 | Var1 <- c(rep(1, 50), rep(0, 50))
20 | Var2 <- c(rep(0, 50), rep(1, 50))
21 | x3 <- matrix(c(Var1, Var2), nrow = 100, ncol = 2)
22 | r1 <- rbm.train(x3, 3, numepochs = 20, cd = 10)
23 | h <- c(0.2, 0.8, 0.1)
24 | v <- rbm.down(r1, h)
25 | }
26 | \author{
27 | Xiao Rong
28 | }
29 | 


--------------------------------------------------------------------------------
/man/rbm.train.Rd:
--------------------------------------------------------------------------------
 1 | \name{rbm.train}
 2 | \alias{rbm.train}
 3 | \title{Training a RBM(restricted Boltzmann Machine)}
 4 | \usage{
 5 | rbm.train(x, hidden, numepochs = 3, batchsize = 100, learningrate = 0.8, 
 6 |     learningrate_scale = 1, momentum = 0.5, visible_type = "bin", hidden_type = "bin", 
 7 |     cd = 1)
 8 | }
 9 | \arguments{
10 |   \item{x}{matrix of x values for examples}
11 | 
12 |   \item{hidden}{number of hidden units}
13 | 
14 |   \item{visible_type}{activation function of input
15 |   unit.Only support "sigm" now}
16 | 
17 |   \item{hidden_type}{activation function of hidden
18 |   unit.Only support "sigm" now}
19 | 
20 |   \item{learningrate}{learning rate for gradient descent.
21 |   Default is 0.8.}
22 | 
23 |   \item{momentum}{momentum for gradient descent. Default is
24 |   0.5 .}
25 | 
26 |   \item{learningrate_scale}{learning rate will be mutiplied
27 |   by this scale after every iteration. Default is 1 .}
28 | 
29 |   \item{numepochs}{number of iteration for samples Default
30 |   is 3.}
31 | 
32 |   \item{batchsize}{size of mini-batch. Default is 100.}
33 | 
34 |   \item{cd}{number of iteration for Gibbs sample of CD
35 |   algorithm.}
36 | }
37 | \description{
38 | Training a RBM(restricted Boltzmann Machine)
39 | }
40 | \examples{
41 | Var1 <- c(rep(1, 50), rep(0, 50))
42 | Var2 <- c(rep(0, 50), rep(1, 50))
43 | x3 <- matrix(c(Var1, Var2), nrow = 100, ncol = 2)
44 | r1 <- rbm.train(x3, 10, numepochs = 20, cd = 10)
45 | }
46 | \author{
47 | Xiao Rong
48 | }
49 | 


--------------------------------------------------------------------------------
/man/rbm.up.Rd:
--------------------------------------------------------------------------------
 1 | \name{rbm.up}
 2 | \alias{rbm.up}
 3 | \title{Infer hidden units state by visible units}
 4 | \usage{
 5 | rbm.up(rbm, v)
 6 | }
 7 | \arguments{
 8 |   \item{rbm}{an rbm object trained by function train.rbm}
 9 | 
10 |   \item{v}{visible units states}
11 | }
12 | \value{
13 | hidden units states
14 | }
15 | \description{
16 | Infer hidden units states by visible units
17 | }
18 | \examples{
19 | Var1 <- c(rep(1, 50), rep(0, 50))
20 | Var2 <- c(rep(0, 50), rep(1, 50))
21 | x3 <- matrix(c(Var1, Var2), nrow = 100, ncol = 2)
22 | r1 <- rbm.train(x3, 3, numepochs = 20, cd = 10)
23 | v <- c(0.2, 0.8)
24 | h <- rbm.up(r1, v)
25 | }
26 | \author{
27 | Xiao Rong
28 | }
29 | 


--------------------------------------------------------------------------------
/man/sae.dnn.train.Rd:
--------------------------------------------------------------------------------
 1 | \name{sae.dnn.train}
 2 | \alias{sae.dnn.train}
 3 | \title{Training a Deep neural network with weights initialized by Stacked AutoEncoder}
 4 | \usage{
 5 | sae.dnn.train(x, y, hidden = c(1), activationfun = "sigm", learningrate = 0.8, 
 6 |     momentum = 0.5, learningrate_scale = 1, output = "sigm", sae_output = "linear", 
 7 |     numepochs = 3, batchsize = 100, hidden_dropout = 0, visible_dropout = 0)
 8 | }
 9 | \arguments{
10 |   \item{x}{matrix of x values for examples}
11 | 
12 |   \item{y}{vector or matrix of target values for examples}
13 | 
14 |   \item{hidden}{vector for number of units of hidden
15 |   layers.Default is c(10).}
16 | 
17 |   \item{activationfun}{activation function of hidden
18 |   unit.Can be "sigm","linear" or "tanh".Default is "sigm"
19 |   for logistic function}
20 | 
21 |   \item{learningrate}{learning rate for gradient descent.
22 |   Default is 0.8.}
23 | 
24 |   \item{momentum}{momentum for gradient descent. Default is
25 |   0.5 .}
26 | 
27 |   \item{learningrate_scale}{learning rate will be mutiplied
28 |   by this scale after every iteration. Default is 1 .}
29 | 
30 |   \item{numepochs}{number of iteration for samples Default
31 |   is 3.}
32 | 
33 |   \item{batchsize}{size of mini-batch. Default is 100.}
34 | 
35 |   \item{output}{function of output unit, can be
36 |   "sigm","linear" or "softmax". Default is "sigm".}
37 | 
38 |   \item{sae_output}{function of autoencoder output unit,
39 |   can be "sigm","linear" or "softmax". Default is
40 |   "linear".}
41 | 
42 |   \item{hidden_dropout}{drop out fraction for hidden layer.
43 |   Default is 0.}
44 | 
45 |   \item{visible_dropout}{drop out fraction for input layer
46 |   Default is 0.}
47 | }
48 | \description{
49 | Training a Deep neural network with weights initialized by
50 | Stacked AutoEncoder
51 | }
52 | \examples{
53 | Var1 <- c(rnorm(50, 1, 0.5), rnorm(50, -0.6, 0.2))
54 | Var2 <- c(rnorm(50, -0.8, 0.2), rnorm(50, 2, 1))
55 | x <- matrix(c(Var1, Var2), nrow = 100, ncol = 2)
56 | y <- c(rep(1, 50), rep(0, 50))
57 | dnn <- sae.dnn.train(x, y, hidden = c(5, 5))
58 | ## predict by dnn
59 | test_Var1 <- c(rnorm(50, 1, 0.5), rnorm(50, -0.6, 0.2))
60 | test_Var2 <- c(rnorm(50, -0.8, 0.2), rnorm(50, 2, 1))
61 | test_x <- matrix(c(test_Var1, test_Var2), nrow = 100, ncol = 2)
62 | nn.test(dnn, test_x, y)
63 | }
64 | \author{
65 | Xiao Rong
66 | }
67 | 


--------------------------------------------------------------------------------