【GitHub】R Deep Learning Cookbook

是 否 +2 论坛币

k人 参与回答

经管之家送您一份

应届毕业生专属福利!

求职就业群

赵安豆老师微信：zhaoandou666

经管之家联合CDA

送您一个全额奖学金名额~ !

立即领取

感谢您参与论坛问题回答

经管之家送您两个论坛币！

+2 论坛币

R Deep Learning Cookbook

This is the code repository for R Deep Learning Cookbook, published by Packt. It contains all the supporting project files necessary to work through the book from start to finish.

About the Book

Deep Learning is the next big thing. It is a part of machine learning. It's favorable results in applications with huge and complex data is remarkable. Simultaneously, R programming language is very popular amongst the data miners and statisticians.

Instructions and Navigation

All of the code is organized into folders. Each folder starts with a number followed by the application name. For example, Chapter02.

The code will look like the following:

[default] exten => s,1,Dial(Zap/1|30) exten => s,2,Voicemail(u100) exten => s,102,Voicemail(b100) exten => i,1,Voicemail(s0)

A lot of inquisitiveness, perseverance, and passion is required to build a strong background in data science. The scope of deep learning is quite broad; thus, the following backgrounds is required to effectively utilize this cookbook:

• Basics of machine learning and data analysis
• Proficiency in R programming
• Basics of Python and Docker Lastly, you need to appreciate deep learning algorithms and know how they solve complex problems in multiple domains
  

Related Products

• R Deep Learning Essentials

• Deep Learning: Practical Neural Networks with Java

• Machine Learning with R Cookbook

  
  

Suggestions and Feedback

Click here if you have any feedback or suggestions.

https://github.com/PacktPublishing/R-Deep-Learning-Cookbook

扫码加我 拉你入群

请注明：姓名-公司-职位

以便审核进群资格，未注明则拒绝

分享0 收藏0 回帖

关键词：Cookbook Learning earning GitHub Learn

1. ###########   COLLABORATIVE FILTERING WITH RBM
   
2. setwd("Set the working directory with movies.dat and ratings.dat files")
   
3. 
   
4. ## Read movie lens data
   
5. txt <- readLines("movies.dat", encoding = "latin1")
   
6. txt_split <- lapply(strsplit(txt, "::"), function(x) as.data.frame(t(x), stringsAsFactors=FALSE))
   
7. movies_df <- do.call(rbind, txt_split)
   
8. names(movies_df) <- c("MovieID", "Title", "Genres")
   
9. movies_df$MovieID <- as.numeric(movies_df$MovieID)
   
10. movies_df$id_order <- 1:nrow(movies_df)
    
11. 
    
12. ratings_df <- read.table("ratings.dat", sep=":",header=FALSE,stringsAsFactors = F)
    
13. ratings_df <- ratings_df[,c(1,3,5,7)]
    
14. colnames(ratings_df) <- c("UserID","MovieID","Rating","Timestamp")
    
15. 
    
16. # Merge user ratings and movies
    
17. merged_df <- merge(movies_df, ratings_df, by="MovieID",all=FALSE)
    
18. 
    
19. # Remove unnecessary columns
    
20. merged_df[,c("Timestamp","Title","Genres")] <- NULL
    
21. 
    
22. # create % rating
    
23. merged_df$rating_per <- merged_df$Rating/5
    
24. 
    
25. # Generate a matrix of ratings
    
26. num_of_users <- 1000
    
27. num_of_movies <- length(unique(movies_df$MovieID))
    
28. trX <- matrix(0,nrow=num_of_users,ncol=num_of_movies)
    
29. for(i in 1:num_of_users){
    
30.   merged_df_user <- merged_df[merged_df$UserID %in% i,]
    
31.   trX[i,merged_df_user$id_order] <- merged_df_user$rating_per
    
32. }
    
33. 
    
34. # Import tenforflow libraries
    
35. # Sys.setenv(TENSORFLOW_PYTHON="C:/PROGRA~1/Python35/python.exe")
    
36. # Sys.setenv(TENSORFLOW_PYTHON_VERSION = 3)
    
37. library(tensorflow)
    
38. np <- import("numpy")
    
39. 
    
40. # Create TensorFlow session
    
41. # Reset the graph
    
42. tf$reset_default_graph()
    
43. # Starting session as interactive session
    
44. sess <- tf$InteractiveSession()
    
45. 
    
46. # Model Parameters
    
47.   num_hidden = 20
    
48.   num_input = nrow(movies_df)
    
49.   vb <- tf$placeholder(tf$float32, shape = shape(num_input))    #Number of unique movies
    
50.   hb <- tf$placeholder(tf$float32, shape = shape(num_hidden))   #Number of features we're going to learn
    
51.   W <- tf$placeholder(tf$float32, shape = shape(num_input, num_hidden))
    
52.   
    
53. #Phase 1: Input Processing
    
54. v0 = tf$placeholder(tf$float32,shape= shape(NULL, num_input))
    
55. prob_h0= tf$nn$sigmoid(tf$matmul(v0, W) + hb)
    
56. h0 = tf$nn$relu(tf$sign(prob_h0 - tf$random_uniform(tf$shape(prob_h0))))
    
57. #Phase 2: Reconstruction
    
58. prob_v1 = tf$nn$sigmoid(tf$matmul(h0, tf$transpose(W)) + vb)
    
59. v1 = tf$nn$relu(tf$sign(prob_v1 - tf$random_uniform(tf$shape(prob_v1))))
    
60. h1 = tf$nn$sigmoid(tf$matmul(v1, W) + hb)
    
61. 
    
62. # RBM Parameters and functions
    
63. #Learning rate
    
64. alpha = 1.0
    
65. #Create the gradients
    
66. w_pos_grad = tf$matmul(tf$transpose(v0), h0)
    
67. w_neg_grad = tf$matmul(tf$transpose(v1), h1)
    
68. #Calculate the Contrastive Divergence to maximize
    
69. CD = (w_pos_grad - w_neg_grad) / tf$to_float(tf$shape(v0)[1])
    
70. #Create methods to update the weights and biases
    
71. update_w = W + alpha * CD
    
72. update_vb = vb + alpha * tf$reduce_mean(v0 - v1)
    
73. update_hb = hb + alpha * tf$reduce_mean(h0 - h1)
    
74. 
    
75. # Mean Absolute Error Function.
    
76. err = v0 - v1
    
77. err_sum = tf$reduce_mean(err * err)
    
78. 
    
79. # Initialise variables (current and previous)
    
80. cur_w = tf$Variable(tf$zeros(shape = shape(num_input, num_hidden), dtype=tf$float32))
    
81. cur_vb = tf$Variable(tf$zeros(shape = shape(num_input), dtype=tf$float32))
    
82. cur_hb = tf$Variable(tf$zeros(shape = shape(num_hidden), dtype=tf$float32))
    
83. prv_w = tf$Variable(tf$random_normal(shape=shape(num_input, num_hidden), stddev=0.01, dtype=tf$float32))
    
84. prv_vb = tf$Variable(tf$zeros(shape = shape(num_input), dtype=tf$float32))
    
85. prv_hb = tf$Variable(tf$zeros(shape = shape(num_hidden), dtype=tf$float32))
    
86. 
    
87. # Start tensorflow session
    
88. sess$run(tf$global_variables_initializer())
    
89. output <- sess$run(list(update_w, update_vb, update_hb), feed_dict = dict(v0=trX,
    
90.                                                                           W = prv_w$eval(),
    
91.                                                                           vb = prv_vb$eval(),
    
92.                                                                           hb = prv_hb$eval()))
    
93. prv_w <- output[[1]]
    
94. prv_vb <- output[[2]]
    
95. prv_hb <-  output[[3]]
    
96. sess$run(err_sum, feed_dict=dict(v0=trX, W= prv_w, vb= prv_vb, hb= prv_hb))
    
97. 
    
98. # Train RBM
    
99. epochs= 500
    
100. errors <- list()
     
101. weights <- list()
     
102. 
     
103. for(ep in 1:epochs){
     
104.   for(i in seq(0,(dim(trX)[1]-100),100)){
     
105.     batchX <- trX[(i+1):(i+100),]
     
106.     output <- sess$run(list(update_w, update_vb, update_hb), feed_dict = dict(v0=batchX,
     
107.                                                                               W = prv_w,
     
108.                                                                               vb = prv_vb,
     
109.                                                                               hb = prv_hb))
     
110.     prv_w <- output[[1]]
     
111.     prv_vb <- output[[2]]
     
112.     prv_hb <-  output[[3]]
     
113.     if(i%%1000 == 0){
     
114.       errors <- c(errors,sess$run(err_sum, feed_dict=dict(v0=batchX, W= prv_w, vb= prv_vb, hb= prv_hb)))
     
115.       weights <- c(weights,output[[1]])
     
116.       cat(i , " : ")
     
117.     }
     
118.   }
     
119.   cat("epoch :", ep, " : reconstruction error : ", errors[length(errors)][[1]],"\n")
     
120. }
     
121. 
     
122. # Plot reconstruction error
     
123. error_vec <- unlist(errors)
     
124. plot(error_vec,xlab="# of batches",ylab="mean squared reconstruction error",main="RBM-Reconstruction MSE plot")
     
125. 
     
126. # Recommendation
     
127. #Selecting the input user
     
128. inputUser = as.matrix(t(trX[75,]))
     
129. names(inputUser) <- movies_df$id_order
     
130. 
     
131. # Remove the movies not watched yet
     
132. inputUser <- inputUser[inputUser>0]
     
133. 
     
134. # Plot the top genre movies
     
135. top_rated_movies <- movies_df[as.numeric(names(inputUser)[order(inputUser,decreasing = TRUE)]),]$Title
     
136. top_rated_genres <- movies_df[as.numeric(names(inputUser)[order(inputUser,decreasing = TRUE)]),]$Genres
     
137. top_rated_genres <- as.data.frame(top_rated_genres,stringsAsFactors=F)
     
138. top_rated_genres$count <- 1
     
139. top_rated_genres <- aggregate(count~top_rated_genres,FUN=sum,data=top_rated_genres)
     
140. top_rated_genres <- top_rated_genres[with(top_rated_genres, order(-count)), ]
     
141. top_rated_genres$top_rated_genres <- factor(top_rated_genres$top_rated_genres, levels = top_rated_genres$top_rated_genres)
     
142. ggplot(top_rated_genres[top_rated_genres$count>1,],aes(x=top_rated_genres,y=count))+
     
143.   geom_bar(stat="identity")+
     
144.   theme_bw()+
     
145.   theme(axis.text.x = element_text(angle = 90, hjust = 1))+
     
146.   labs(x="Genres",y="count",title="Top Rated Genres")+
     
147.   theme(plot.title = element_text(hjust = 0.5))
     
148.   
     
149. 
     
150. #Feeding in the user and reconstructing the input
     
151. hh0 = tf$nn$sigmoid(tf$matmul(v0, W) + hb)
     
152. vv1 = tf$nn$sigmoid(tf$matmul(hh0, tf$transpose(W)) + vb)
     
153. feed = sess$run(hh0, feed_dict=dict( v0= inputUser, W= prv_w, hb= prv_hb))
     
154. rec = sess$run(vv1, feed_dict=dict( hh0= feed, W= prv_w, vb= prv_vb))
     
155. names(rec) <- movies_df$id_order
     
156. 
     
157. # Select all recommended movies
     
158. top_recom_movies <- movies_df[as.numeric(names(rec)[order(rec,decreasing = TRUE)]),]$Title[1:10]
     
159. top_recom_genres <- movies_df[as.numeric(names(rec)[order(rec,decreasing = TRUE)]),]$Genres
     
160. top_recom_genres <- as.data.frame(top_recom_genres,stringsAsFactors=F)
     
161. top_recom_genres$count <- 1
     
162. top_recom_genres <- aggregate(count~top_recom_genres,FUN=sum,data=top_recom_genres)
     
163. top_recom_genres <- top_recom_genres[with(top_recom_genres, order(-count)), ]
     
164. top_recom_genres$top_recom_genres <- factor(top_recom_genres$top_recom_genres, levels = top_recom_genres$top_recom_genres)
     
165. ggplot(top_recom_genres[top_recom_genres$count>20,],aes(x=top_recom_genres,y=count))+
     
166.   geom_bar(stat="identity")+
     
167.   theme_bw()+
     
168.   theme(axis.text.x = element_text(angle = 90, hjust = 1))+
     
169.   labs(x="Genres",y="count",title="Top Recommended Genres")+
     
170.   theme(plot.title = element_text(hjust = 0.5))

复制代码

1. ######  DEEP BELIEF NETWORKS
   
2. # Import tenforflow libraries
   
3. # Sys.setenv(TENSORFLOW_PYTHON="C:/PROGRA~1/Python35/python.exe")
   
4. # Sys.setenv(TENSORFLOW_PYTHON_VERSION = 3)
   
5. library(tensorflow)
   
6. np <- import("numpy")
   
7. 
   
8. # Create TensorFlow session
   
9. # Reset the graph
   
10. tf$reset_default_graph()
    
11. # Starting session as interactive session
    
12. sess <- tf$InteractiveSession()
    
13. 
    
14. # Input data (MNIST)
    
15. mnist <- tf$examples$tutorials$mnist$input_data$read_data_sets("MNIST-data/",one_hot=TRUE)
    
16. trainX <- mnist$train$images
    
17. trainY <- mnist$train$labels
    
18. testX <- mnist$test$images
    
19. testY <- mnist$test$labels
    
20. 
    
21. # Creating DBN
    
22. RBM_hidden_sizes = c(900, 500 , 300 )
    
23. 
    
24. 
    
25. # Function to initialize RBM
    
26. RBM <- function(input_data,
    
27.                 num_input,
    
28.                 num_output,
    
29.                 epochs = 5,
    
30.                 alpha = 0.1,
    
31.                 batchsize=100){
    
32.   
    
33.   # Placeholder variables
    
34.   vb <- tf$placeholder(tf$float32, shape = shape(num_input))
    
35.   hb <- tf$placeholder(tf$float32, shape = shape(num_output))
    
36.   W <- tf$placeholder(tf$float32, shape = shape(num_input, num_output))
    
37.   
    
38.   # Phase 1 : Forward Pass
    
39.   X = tf$placeholder(tf$float32, shape=shape(NULL, num_input))
    
40.   prob_h0= tf$nn$sigmoid(tf$matmul(X, W) + hb)  #probabilities of the hidden units
    
41.   h0 = tf$nn$relu(tf$sign(prob_h0 - tf$random_uniform(tf$shape(prob_h0)))) #sample_h_given_X
    
42.   
    
43.   # Phase 2 : Backward Pass
    
44.   prob_v1 = tf$nn$sigmoid(tf$matmul(h0, tf$transpose(W)) + vb)
    
45.   v1 = tf$nn$relu(tf$sign(prob_v1 - tf$random_uniform(tf$shape(prob_v1))))
    
46.   h1 = tf$nn$sigmoid(tf$matmul(v1, W) + hb)   
    
47.   
    
48.   # Calculate gradients
    
49.   w_pos_grad = tf$matmul(tf$transpose(X), h0)
    
50.   w_neg_grad = tf$matmul(tf$transpose(v1), h1)
    
51.   CD = (w_pos_grad - w_neg_grad) / tf$to_float(tf$shape(X)[0])
    
52.   update_w = W + alpha * CD
    
53.   update_vb = vb + alpha * tf$reduce_mean(X - v1)
    
54.   update_hb = hb + alpha * tf$reduce_mean(h0 - h1)
    
55.   
    
56.   # Objective function
    
57.   err = tf$reduce_mean(tf$square(X - v1))
    
58.   
    
59.   # Initialise variables
    
60.   cur_w = tf$Variable(tf$zeros(shape = shape(num_input, num_output), dtype=tf$float32))
    
61.   cur_vb = tf$Variable(tf$zeros(shape = shape(num_input), dtype=tf$float32))
    
62.   cur_hb = tf$Variable(tf$zeros(shape = shape(num_output), dtype=tf$float32))
    
63.   prv_w = tf$Variable(tf$random_normal(shape=shape(num_input, num_output), stddev=0.01, dtype=tf$float32))
    
64.   prv_vb = tf$Variable(tf$zeros(shape = shape(num_input), dtype=tf$float32))
    
65.   prv_hb = tf$Variable(tf$zeros(shape = shape(num_output), dtype=tf$float32))
    
66.   
    
67.   # Start tensorflow session
    
68.   sess$run(tf$global_variables_initializer())
    
69.   output <- sess$run(list(update_w, update_vb, update_hb), feed_dict = dict(X=input_data,
    
70.                                                                             W = prv_w$eval(),
    
71.                                                                             vb = prv_vb$eval(),
    
72.                                                                             hb = prv_hb$eval()))
    
73.   prv_w <- output[[1]]
    
74.   prv_vb <- output[[2]]
    
75.   prv_hb <-  output[[3]]
    
76.   sess$run(err, feed_dict=dict(X= input_data, W= prv_w, vb= prv_vb, hb= prv_hb))
    
77.   
    
78.   errors <- list()
    
79.   weights <- list()
    
80.   u=1
    
81.   for(ep in 1:epochs){
    
82.     for(i in seq(0,(dim(input_data)[1]-batchsize),batchsize)){
    
83.       batchX <- input_data[(i+1):(i+batchsize),]
    
84.       output <- sess$run(list(update_w, update_vb, update_hb), feed_dict = dict(X=batchX,
    
85.                                                                                 W = prv_w,
    
86.                                                                                 vb = prv_vb,
    
87.                                                                                 hb = prv_hb))
    
88.       prv_w <- output[[1]]
    
89.       prv_vb <- output[[2]]
    
90.       prv_hb <-  output[[3]]
    
91.       if(i%%10000 == 0){
    
92.         errors[[u]] <- sess$run(err, feed_dict=dict(X= batchX, W= prv_w, vb= prv_vb, hb= prv_hb))
    
93.         weights[[u]] <- output[[1]]
    
94.         u=u+1
    
95.         cat(i , " : ")
    
96.       }
    
97.     }
    
98.     cat("epoch :", ep, " : reconstruction error : ", errors[length(errors)][[1]],"\n")
    
99.   }
    
100.   
     
101.   w <- prv_w
     
102.   vb <- prv_vb
     
103.   hb <- prv_hb
     
104.   
     
105.   # Get the output
     
106.   input_X = tf$constant(input_data)
     
107.   ph_w = tf$constant(w)
     
108.   ph_hb = tf$constant(hb)
     
109.   
     
110.   out = tf$nn$sigmoid(tf$matmul(input_X, ph_w) + ph_hb)
     
111. 
     
112.   sess$run(tf$global_variables_initializer())
     
113.   return(list(output_data = sess$run(out),
     
114.               error_list=errors,
     
115.               weight_list=weights,
     
116.               weight_final=w,
     
117.               bias_final=hb))
     
118. }
     
119. 
     
120. #Since we are training, set input as training data
     
121. inpX = trainX
     
122. 
     
123. #Size of inputs is the number of inputs in the training set
     
124. num_input = ncol(inpX)
     
125. 
     
126. #Train RBM
     
127. RBM_output <- list()
     
128. for(i in 1:length(RBM_hidden_sizes)){
     
129.   size <- RBM_hidden_sizes[i]
     
130.   
     
131.   # Train the RBM
     
132.   RBM_output[[i]] <- RBM(input_data=inpX,
     
133.                          num_input=num_input,
     
134.                          num_output=size,
     
135.                          epochs = 5,
     
136.                          alpha = 0.1,
     
137.                          batchsize=100)
     
138.   
     
139.   # Update the input data
     
140.   inpX <- RBM_output[[i]]$output_data
     
141.    
     
142.   
     
143.   # Update the input_size
     
144.   num_input = size
     
145.   
     
146.   cat("completed size :", size,"\n")
     
147. }
     
148. 
     
149. # Plot reconstruction error
     
150. error_df <- data.frame("error"=c(unlist(RBM_output[[1]]$error_list),unlist(RBM_output[[2]]$error_list),unlist(RBM_output[[3]]$error_list)),
     
151.                        "batches"=c(rep(seq(1:length(unlist(RBM_output[[1]]$error_list))),times=3)),
     
152.                        "hidden_layer"=c(rep(c(1,2,3),each=length(unlist(RBM_output[[1]]$error_list)))),
     
153.                        stringsAsFactors = FALSE)
     
154. 
     
155. plot(error ~ batches,
     
156.      xlab = "# of batches",
     
157.      ylab = "Reconstruction Error",
     
158.      pch = c(1, 7, 16)[hidden_layer],
     
159.      main = "Stacked RBM-Reconstruction MSE plot",
     
160.      data = error_df)
     
161. 
     
162. legend('topright',
     
163.        c("H1_900","H2_500","H3_300"),
     
164.        pch = c(1, 7, 16))

复制代码

1. Sys.setenv(TENSORFLOW_PYTHON="C:/PROGRA~3/ANACON~1/python.exe")
   
2. Sys.setenv(TENSORFLOW_PYTHON_VERSION = 3)
   
3. library(tensorflow)
   
4. require(imager)
   
5. require(caret)
   
6. 
   
7. # Load mnist dataset from tensorflow library
   
8. datasets <- tf$contrib$learn$datasets
   
9. mnist <- datasets$mnist$read_data_sets("MNIST-data", one_hot = TRUE)
   
10. 
    
11. 
    
12. # Function to plot MNIST dataset
    
13. plot_mnist<-function(imageD, pixel.y=16){
    
14.   require(imager)
    
15.   actImage<-matrix(imageD, ncol=pixel.y, byrow=FALSE)
    
16.   img.col.mat <- imappend(list(as.cimg(actImage)), "c")
    
17.   plot(img.col.mat, axes=F)
    
18. }
    
19. 
    
20. # Reduce Image Size
    
21. reduceImage<-function(actds, n.pixel.x=16, n.pixel.y=16){
    
22.   actImage<-matrix(actds, ncol=28, byrow=FALSE)
    
23.   img.col.mat <- imappend(list(as.cimg(actImage)),"c")
    
24.   thmb <- resize(img.col.mat, n.pixel.x, n.pixel.y)
    
25.   outputImage<-matrix(thmb[,,1,1], nrow = 1, byrow = F)
    
26.   return(outputImage)
    
27. }
    
28. 
    
29. # Covert train data to 16 x 16  pixel image
    
30. trainData<-t(apply(mnist$train$images, 1, FUN=reduceImage))
    
31. validData<-t(apply(mnist$test$images, 1, FUN=reduceImage))
    
32. labels <- mnist$train$labels
    
33. labels_valid <- mnist$test$labels
    
34. rm(mnist)
    
35. 
    
36. 
    
37. # Reset the graph and set-up a interactive session
    
38. tf$reset_default_graph()
    
39. sess<-tf$InteractiveSession()
    
40. 
    
41. # Define Model parameter
    
42. n_input<-16
    
43. step_size<-16
    
44. n.hidden<-64
    
45. n.class<-10
    
46. 
    
47. # Define training parameter
    
48. lr<-0.01
    
49. batch<-500
    
50. iteration = 100
    
51. 
    
52. # Set up a most basic RNN
    
53. rnn<-function(x, weight, bias){
    
54.   # Unstack input into step_size
    
55.   x = tf$unstack(x, step_size, 1)
    
56.   
    
57.   # Define a most basic RNN
    
58.   rnn_cell = tf$contrib$rnn$BasicRNNCell(n.hidden)
    
59.   
    
60.   # create a recurrent neural network
    
61.   cell_output = tf$contrib$rnn$static_rnn(rnn_cell, x, dtype=tf$float32)
    
62.   
    
63.   # Linear activation, using rnn inner loop
    
64.   last_vec=tail(cell_output[[1]], n=1)[[1]]
    
65.   return(tf$matmul(last_vec, weights) + bias)
    
66. }
    
67. 
    
68. # Function to evaluate mean accuracy
    
69. eval_acc<-function(yhat, y){
    
70.   # Count correct solution
    
71.   correct_Count = tf$equal(tf$argmax(yhat,1L), tf$argmax(y,1L))
    
72.   
    
73.   # Mean accuracy
    
74.   mean_accuracy = tf$reduce_mean(tf$cast(correct_Count, tf$float32))
    
75.   
    
76.   return(mean_accuracy)
    
77. }
    
78. 
    
79. with(tf$name_scope('input'), {
    
80. # Define placeholder for input data
    
81. x = tf$placeholder(tf$float32, shape=shape(NULL, step_size, n_input), name='x')
    
82. y <- tf$placeholder(tf$float32, shape(NULL, n.class), name='y')
    
83. 
    
84. # Define Weights and bias
    
85. weights <- tf$Variable(tf$random_normal(shape(n.hidden, n.class)))
    
86. bias <- tf$Variable(tf$random_normal(shape(n.class)))
    
87. })
    
88. 
    
89. # Evaluate rnn cell output
    
90. yhat = rnn(x, weights, bias)
    
91. 
    
92. # Define loss and optimizer
    
93. cost = tf$reduce_mean(tf$nn$softmax_cross_entropy_with_logits(logits=yhat, labels=y))
    
94. optimizer = tf$train$AdamOptimizer(learning_rate=lr)$minimize(cost)
    
95. 
    
96. 
    
97. 
    
98. # Run optimization
    
99. sess$run(tf$global_variables_initializer())
    
100. 
     
101. # Running optimization
     
102. for(i in 1:iteration){
     
103.   spls <- sample(1:dim(trainData)[1],batch)
     
104.   sample_data<-trainData[spls,]
     
105.   sample_y<-labels[spls,]
     
106.   
     
107.   # Reshape sample into 16 sequence with each of 16 element
     
108.   sample_data=tf$reshape(sample_data, shape(batch, step_size, n_input))
     
109.   out<-optimizer$run(feed_dict = dict(x=sample_data$eval(), y=sample_y))
     
110.   
     
111.   if (i %% 1 == 0){
     
112.     cat("iteration - ", i, "Training Loss - ",  cost$eval(feed_dict = dict(x=sample_data$eval(), y=sample_y)), "\n")
     
113.   }
     
114. }
     
115. 
     
116. 
     
117. # Calculate accuracy for 128 mnist test images
     
118. accuracy<-eval_acc(yhat, y)
     
119. valid_data=tf$reshape(validData, shape(-1, step_size, n_input))
     
120. yhat<-sess$run(tf$argmax(yhat, 1L), feed_dict = dict(x = valid_data$eval()))
     
121. image(t(matrix(validData[20,], ncol = 16, nrow = 16, byrow = T)), col  = gray((0:32)/32))
     
122. image(t(matrix(trainData[20,], ncol = 16, nrow = 16, byrow = T)), col  = gray((0:32)/32))
     
123. 
     
124. cost$eval(feed_dict=dict(x=valid_data$eval(), y=labels_valid))

复制代码

谢谢楼主分享！

Deep Learning Cookbook