From 160eddddc4e265d5ee59a38797c30720bf46cd7c Mon Sep 17 00:00:00 2001
From: AlexeyAB <alexeyab84@gmail.com>
Date: Sun, 27 May 2018 13:53:42 +0000
Subject: [PATCH] Minor fix
---
src/route_layer.c | 124 ++++++++++++++++++++++++++++-------------
1 files changed, 85 insertions(+), 39 deletions(-)
diff --git a/src/route_layer.c b/src/route_layer.c
index c8897b1..dce7118 100644
--- a/src/route_layer.c
+++ b/src/route_layer.c
@@ -3,83 +3,129 @@
#include "blas.h"
#include <stdio.h>
-route_layer *make_route_layer(int batch, int n, int *input_layers, int *input_sizes)
+route_layer make_route_layer(int batch, int n, int *input_layers, int *input_sizes)
{
- printf("Route Layer:");
- route_layer *layer = calloc(1, sizeof(route_layer));
- layer->batch = batch;
- layer->n = n;
- layer->input_layers = input_layers;
- layer->input_sizes = input_sizes;
+ fprintf(stderr,"route ");
+ route_layer l = {0};
+ l.type = ROUTE;
+ l.batch = batch;
+ l.n = n;
+ l.input_layers = input_layers;
+ l.input_sizes = input_sizes;
int i;
int outputs = 0;
for(i = 0; i < n; ++i){
- printf(" %d", input_layers[i]);
+ fprintf(stderr," %d", input_layers[i]);
outputs += input_sizes[i];
}
- printf("\n");
- layer->outputs = outputs;
- layer->delta = calloc(outputs*batch, sizeof(float));
- layer->output = calloc(outputs*batch, sizeof(float));;
+ fprintf(stderr, "\n");
+ l.outputs = outputs;
+ l.inputs = outputs;
+ l.delta = calloc(outputs*batch, sizeof(float));
+ l.output = calloc(outputs*batch, sizeof(float));;
+
+ l.forward = forward_route_layer;
+ l.backward = backward_route_layer;
#ifdef GPU
- layer->delta_gpu = cuda_make_array(0, outputs*batch);
- layer->output_gpu = cuda_make_array(0, outputs*batch);
+ l.forward_gpu = forward_route_layer_gpu;
+ l.backward_gpu = backward_route_layer_gpu;
+
+ l.delta_gpu = cuda_make_array(l.delta, outputs*batch);
+ l.output_gpu = cuda_make_array(l.output, outputs*batch);
#endif
- return layer;
+ return l;
}
-void forward_route_layer(const route_layer layer, network net)
+void resize_route_layer(route_layer *l, network *net)
+{
+ int i;
+ layer first = net->layers[l->input_layers[0]];
+ l->out_w = first.out_w;
+ l->out_h = first.out_h;
+ l->out_c = first.out_c;
+ l->outputs = first.outputs;
+ l->input_sizes[0] = first.outputs;
+ for(i = 1; i < l->n; ++i){
+ int index = l->input_layers[i];
+ layer next = net->layers[index];
+ l->outputs += next.outputs;
+ l->input_sizes[i] = next.outputs;
+ if(next.out_w == first.out_w && next.out_h == first.out_h){
+ l->out_c += next.out_c;
+ }else{
+ printf("%d %d, %d %d\n", next.out_w, next.out_h, first.out_w, first.out_h);
+ l->out_h = l->out_w = l->out_c = 0;
+ }
+ }
+ l->inputs = l->outputs;
+ l->delta = realloc(l->delta, l->outputs*l->batch*sizeof(float));
+ l->output = realloc(l->output, l->outputs*l->batch*sizeof(float));
+
+#ifdef GPU
+ cuda_free(l->output_gpu);
+ cuda_free(l->delta_gpu);
+ l->output_gpu = cuda_make_array(l->output, l->outputs*l->batch);
+ l->delta_gpu = cuda_make_array(l->delta, l->outputs*l->batch);
+#endif
+
+}
+
+void forward_route_layer(const route_layer l, network_state state)
{
int i, j;
int offset = 0;
- for(i = 0; i < layer.n; ++i){
- float *input = get_network_output_layer(net, layer.input_layers[i]);
- int input_size = layer.input_sizes[i];
- for(j = 0; j < layer.batch; ++j){
- copy_cpu(input_size, input + j*input_size, 1, layer.output + offset + j*layer.outputs, 1);
+ for(i = 0; i < l.n; ++i){
+ int index = l.input_layers[i];
+ float *input = state.net.layers[index].output;
+ int input_size = l.input_sizes[i];
+ for(j = 0; j < l.batch; ++j){
+ copy_cpu(input_size, input + j*input_size, 1, l.output + offset + j*l.outputs, 1);
}
offset += input_size;
}
}
-void backward_route_layer(const route_layer layer, network net)
+void backward_route_layer(const route_layer l, network_state state)
{
int i, j;
int offset = 0;
- for(i = 0; i < layer.n; ++i){
- float *delta = get_network_delta_layer(net, layer.input_layers[i]);
- int input_size = layer.input_sizes[i];
- for(j = 0; j < layer.batch; ++j){
- copy_cpu(input_size, layer.delta + offset + j*layer.outputs, 1, delta + j*input_size, 1);
+ for(i = 0; i < l.n; ++i){
+ int index = l.input_layers[i];
+ float *delta = state.net.layers[index].delta;
+ int input_size = l.input_sizes[i];
+ for(j = 0; j < l.batch; ++j){
+ axpy_cpu(input_size, 1, l.delta + offset + j*l.outputs, 1, delta + j*input_size, 1);
}
offset += input_size;
}
}
#ifdef GPU
-void forward_route_layer_gpu(const route_layer layer, network net)
+void forward_route_layer_gpu(const route_layer l, network_state state)
{
int i, j;
int offset = 0;
- for(i = 0; i < layer.n; ++i){
- float *input = get_network_output_gpu_layer(net, layer.input_layers[i]);
- int input_size = layer.input_sizes[i];
- for(j = 0; j < layer.batch; ++j){
- copy_ongpu(input_size, input + j*input_size, 1, layer.output_gpu + offset + j*layer.outputs, 1);
+ for(i = 0; i < l.n; ++i){
+ int index = l.input_layers[i];
+ float *input = state.net.layers[index].output_gpu;
+ int input_size = l.input_sizes[i];
+ for(j = 0; j < l.batch; ++j){
+ copy_ongpu(input_size, input + j*input_size, 1, l.output_gpu + offset + j*l.outputs, 1);
}
offset += input_size;
}
}
-void backward_route_layer_gpu(const route_layer layer, network net)
+void backward_route_layer_gpu(const route_layer l, network_state state)
{
int i, j;
int offset = 0;
- for(i = 0; i < layer.n; ++i){
- float *delta = get_network_delta_gpu_layer(net, layer.input_layers[i]);
- int input_size = layer.input_sizes[i];
- for(j = 0; j < layer.batch; ++j){
- copy_ongpu(input_size, layer.delta_gpu + offset + j*layer.outputs, 1, delta + j*input_size, 1);
+ for(i = 0; i < l.n; ++i){
+ int index = l.input_layers[i];
+ float *delta = state.net.layers[index].delta_gpu;
+ int input_size = l.input_sizes[i];
+ for(j = 0; j < l.batch; ++j){
+ axpy_ongpu(input_size, 1, l.delta_gpu + offset + j*l.outputs, 1, delta + j*input_size, 1);
}
offset += input_size;
}
--
Gitblit v1.10.0