From c7c1e0e7b719711ddaf13f128a18e6830d5941e3 Mon Sep 17 00:00:00 2001
From: Joseph Redmon <pjreddie@gmail.com>
Date: Fri, 05 Feb 2016 08:15:12 +0000
Subject: [PATCH] rnn stuff

---
 src/network_kernels.cu |   24 +++++++++++++++++++++++-
 1 files changed, 23 insertions(+), 1 deletions(-)

diff --git a/src/network_kernels.cu b/src/network_kernels.cu
index 26b8404..ea12819 100644
--- a/src/network_kernels.cu
+++ b/src/network_kernels.cu
@@ -11,13 +11,14 @@
 #include "image.h"
 #include "data.h"
 #include "utils.h"
-#include "params.h"
 #include "parser.h"
 
 #include "crop_layer.h"
 #include "connected_layer.h"
+#include "rnn_layer.h"
 #include "detection_layer.h"
 #include "convolutional_layer.h"
+#include "activation_layer.h"
 #include "deconvolutional_layer.h"
 #include "maxpool_layer.h"
 #include "avgpool_layer.h"
@@ -27,6 +28,7 @@
 #include "softmax_layer.h"
 #include "dropout_layer.h"
 #include "route_layer.h"
+#include "shortcut_layer.h"
 #include "blas.h"
 }
 
@@ -38,6 +40,7 @@
 {
     int i;
     for(i = 0; i < net.n; ++i){
+        state.index = i;
         layer l = net.layers[i];
         if(l.delta_gpu){
             fill_ongpu(l.outputs * l.batch, 0, l.delta_gpu, 1);
@@ -46,12 +49,16 @@
             forward_convolutional_layer_gpu(l, state);
         } else if(l.type == DECONVOLUTIONAL){
             forward_deconvolutional_layer_gpu(l, state);
+        } else if(l.type == ACTIVE){
+            forward_activation_layer_gpu(l, state);
         } else if(l.type == LOCAL){
             forward_local_layer_gpu(l, state);
         } else if(l.type == DETECTION){
             forward_detection_layer_gpu(l, state);
         } else if(l.type == CONNECTED){
             forward_connected_layer_gpu(l, state);
+        } else if(l.type == RNN){
+            forward_rnn_layer_gpu(l, state);
         } else if(l.type == CROP){
             forward_crop_layer_gpu(l, state);
         } else if(l.type == COST){
@@ -68,6 +75,8 @@
             forward_dropout_layer_gpu(l, state);
         } else if(l.type == ROUTE){
             forward_route_layer_gpu(l, net);
+        } else if(l.type == SHORTCUT){
+            forward_shortcut_layer_gpu(l, state);
         }
         state.input = l.output_gpu;
     }
@@ -79,6 +88,7 @@
     float * original_input = state.input;
     float * original_delta = state.delta;
     for(i = net.n-1; i >= 0; --i){
+        state.index = i;
         layer l = net.layers[i];
         if(i == 0){
             state.input = original_input;
@@ -92,6 +102,8 @@
             backward_convolutional_layer_gpu(l, state);
         } else if(l.type == DECONVOLUTIONAL){
             backward_deconvolutional_layer_gpu(l, state);
+        } else if(l.type == ACTIVE){
+            backward_activation_layer_gpu(l, state);
         } else if(l.type == LOCAL){
             backward_local_layer_gpu(l, state);
         } else if(l.type == MAXPOOL){
@@ -108,10 +120,14 @@
             if(i != 0) backward_softmax_layer_gpu(l, state);
         } else if(l.type == CONNECTED){
             backward_connected_layer_gpu(l, state);
+        } else if(l.type == RNN){
+            backward_rnn_layer_gpu(l, state);
         } else if(l.type == COST){
             backward_cost_layer_gpu(l, state);
         } else if(l.type == ROUTE){
             backward_route_layer_gpu(l, net);
+        } else if(l.type == SHORTCUT){
+            backward_shortcut_layer_gpu(l, state);
         }
     }
 }
@@ -129,6 +145,8 @@
             update_deconvolutional_layer_gpu(l, rate, net.momentum, net.decay);
         } else if(l.type == CONNECTED){
             update_connected_layer_gpu(l, update_batch, rate, net.momentum, net.decay);
+        } else if(l.type == RNN){
+            update_rnn_layer_gpu(l, update_batch, rate, net.momentum, net.decay);
         } else if(l.type == LOCAL){
             update_local_layer_gpu(l, update_batch, rate, net.momentum, net.decay);
         }
@@ -138,6 +156,8 @@
 float train_network_datum_gpu(network net, float *x, float *y)
 {
     network_state state;
+    state.index = 0;
+    state.net = net;
     int x_size = get_network_input_size(net)*net.batch;
     int y_size = get_network_output_size(net)*net.batch;
     if(net.layers[net.n-1].type == DETECTION) y_size = net.layers[net.n-1].truths*net.batch;
@@ -178,6 +198,8 @@
 {
     int size = get_network_input_size(net) * net.batch;
     network_state state;
+    state.index = 0;
+    state.net = net;
     state.input = cuda_make_array(input, size);
     state.truth = 0;
     state.train = 0;

--
Gitblit v1.10.0