From 064d4462d3890fd5dda5c7845119e1a3854d477b Mon Sep 17 00:00:00 2001
From: Joseph Redmon <pjreddie@gmail.com>
Date: Thu, 26 Nov 2015 21:45:12 +0000
Subject: [PATCH] stuff
---
src/convolutional_layer.c | 151 +++++++++++++++++++++++++++++++++++++++++++-------
1 files changed, 130 insertions(+), 21 deletions(-)
diff --git a/src/convolutional_layer.c b/src/convolutional_layer.c
index b6437d4..b9fd3c9 100644
--- a/src/convolutional_layer.c
+++ b/src/convolutional_layer.c
@@ -41,7 +41,7 @@
return float_to_image(w,h,c,l.delta);
}
-convolutional_layer make_convolutional_layer(int batch, int h, int w, int c, int n, int size, int stride, int pad, ACTIVATION activation)
+convolutional_layer make_convolutional_layer(int batch, int h, int w, int c, int n, int size, int stride, int pad, ACTIVATION activation, int batch_normalize)
{
int i;
convolutional_layer l = {0};
@@ -55,17 +55,17 @@
l.stride = stride;
l.size = size;
l.pad = pad;
+ l.batch_normalize = batch_normalize;
l.filters = calloc(c*n*size*size, sizeof(float));
l.filter_updates = calloc(c*n*size*size, sizeof(float));
l.biases = calloc(n, sizeof(float));
l.bias_updates = calloc(n, sizeof(float));
- float scale = 1./sqrt(size*size*c);
+
+ // float scale = 1./sqrt(size*size*c);
+ float scale = sqrt(2./(size*size*c));
for(i = 0; i < c*n*size*size; ++i) l.filters[i] = 2*scale*rand_uniform() - scale;
- for(i = 0; i < n; ++i){
- l.biases[i] = scale;
- }
int out_h = convolutional_out_height(l);
int out_w = convolutional_out_width(l);
l.out_h = out_h;
@@ -78,17 +78,55 @@
l.output = calloc(l.batch*out_h * out_w * n, sizeof(float));
l.delta = calloc(l.batch*out_h * out_w * n, sizeof(float));
- #ifdef GPU
+ if(batch_normalize){
+ l.scales = calloc(n, sizeof(float));
+ l.scale_updates = calloc(n, sizeof(float));
+ for(i = 0; i < n; ++i){
+ l.scales[i] = 1;
+ }
+
+ l.mean = calloc(n, sizeof(float));
+ l.spatial_mean = calloc(n*l.batch, sizeof(float));
+
+ l.variance = calloc(n, sizeof(float));
+ l.rolling_mean = calloc(n, sizeof(float));
+ l.rolling_variance = calloc(n, sizeof(float));
+ }
+
+#ifdef GPU
l.filters_gpu = cuda_make_array(l.filters, c*n*size*size);
l.filter_updates_gpu = cuda_make_array(l.filter_updates, c*n*size*size);
l.biases_gpu = cuda_make_array(l.biases, n);
l.bias_updates_gpu = cuda_make_array(l.bias_updates, n);
+ l.scales_gpu = cuda_make_array(l.scales, n);
+ l.scale_updates_gpu = cuda_make_array(l.scale_updates, n);
+
l.col_image_gpu = cuda_make_array(l.col_image, out_h*out_w*size*size*c);
l.delta_gpu = cuda_make_array(l.delta, l.batch*out_h*out_w*n);
l.output_gpu = cuda_make_array(l.output, l.batch*out_h*out_w*n);
- #endif
+
+ if(batch_normalize){
+ l.mean_gpu = cuda_make_array(l.mean, n);
+ l.variance_gpu = cuda_make_array(l.variance, n);
+
+ l.rolling_mean_gpu = cuda_make_array(l.mean, n);
+ l.rolling_variance_gpu = cuda_make_array(l.variance, n);
+
+ l.spatial_mean_gpu = cuda_make_array(l.spatial_mean, n*l.batch);
+ l.spatial_variance_gpu = cuda_make_array(l.spatial_mean, n*l.batch);
+
+ l.spatial_mean_delta_gpu = cuda_make_array(l.spatial_mean, n*l.batch);
+ l.spatial_variance_delta_gpu = cuda_make_array(l.spatial_mean, n*l.batch);
+
+ l.mean_delta_gpu = cuda_make_array(l.mean, n);
+ l.variance_delta_gpu = cuda_make_array(l.variance, n);
+
+ l.x_gpu = cuda_make_array(l.output, l.batch*out_h*out_w*n);
+ l.x_norm_gpu = cuda_make_array(l.output, l.batch*out_h*out_w*n);
+ }
+#endif
l.activation = activation;
fprintf(stderr, "Convolutional Layer: %d x %d x %d image, %d filters -> %d x %d x %d image\n", h,w,c,n, out_h, out_w, n);
@@ -96,29 +134,71 @@
return l;
}
-void resize_convolutional_layer(convolutional_layer *l, int h, int w)
+void denormalize_convolutional_layer(convolutional_layer l)
{
- l->h = h;
+ int i, j;
+ for(i = 0; i < l.n; ++i){
+ float scale = l.scales[i]/sqrt(l.rolling_variance[i] + .00001);
+ for(j = 0; j < l.c*l.size*l.size; ++j){
+ l.filters[i*l.c*l.size*l.size + j] *= scale;
+ }
+ l.biases[i] -= l.rolling_mean[i] * scale;
+ }
+}
+
+void test_convolutional_layer()
+{
+ convolutional_layer l = make_convolutional_layer(1, 5, 5, 3, 2, 5, 2, 1, LEAKY, 1);
+ l.batch_normalize = 1;
+ float data[] = {1,1,1,1,1,
+ 1,1,1,1,1,
+ 1,1,1,1,1,
+ 1,1,1,1,1,
+ 1,1,1,1,1,
+ 2,2,2,2,2,
+ 2,2,2,2,2,
+ 2,2,2,2,2,
+ 2,2,2,2,2,
+ 2,2,2,2,2,
+ 3,3,3,3,3,
+ 3,3,3,3,3,
+ 3,3,3,3,3,
+ 3,3,3,3,3,
+ 3,3,3,3,3};
+ network_state state = {0};
+ state.input = data;
+ forward_convolutional_layer(l, state);
+}
+
+void resize_convolutional_layer(convolutional_layer *l, int w, int h)
+{
l->w = w;
- int out_h = convolutional_out_height(*l);
+ l->h = h;
int out_w = convolutional_out_width(*l);
+ int out_h = convolutional_out_height(*l);
+
+ l->out_w = out_w;
+ l->out_h = out_h;
+
+ l->outputs = l->out_h * l->out_w * l->out_c;
+ l->inputs = l->w * l->h * l->c;
l->col_image = realloc(l->col_image,
- out_h*out_w*l->size*l->size*l->c*sizeof(float));
+ out_h*out_w*l->size*l->size*l->c*sizeof(float));
l->output = realloc(l->output,
- l->batch*out_h * out_w * l->n*sizeof(float));
+ l->batch*out_h * out_w * l->n*sizeof(float));
l->delta = realloc(l->delta,
- l->batch*out_h * out_w * l->n*sizeof(float));
+ l->batch*out_h * out_w * l->n*sizeof(float));
- #ifdef GPU
+#ifdef GPU
cuda_free(l->col_image_gpu);
cuda_free(l->delta_gpu);
cuda_free(l->output_gpu);
l->col_image_gpu = cuda_make_array(l->col_image, out_h*out_w*l->size*l->size*l->c);
- l->delta_gpu = cuda_make_array(l->delta, l->batch*out_h*out_w*l->n);
- l->output_gpu = cuda_make_array(l->output, l->batch*out_h*out_w*l->n);
- #endif
+ l->delta_gpu = cuda_make_array(l->delta, l->batch*out_h*out_w*l->n);
+ l->output_gpu = cuda_make_array(l->output, l->batch*out_h*out_w*l->n);
+#endif
}
void bias_output(float *output, float *biases, int batch, int n, int size)
@@ -143,7 +223,6 @@
}
}
-
void forward_convolutional_layer(const convolutional_layer l, network_state state)
{
int out_h = convolutional_out_height(l);
@@ -162,11 +241,18 @@
for(i = 0; i < l.batch; ++i){
im2col_cpu(state.input, l.c, l.h, l.w,
- l.size, l.stride, l.pad, b);
+ l.size, l.stride, l.pad, b);
gemm(0,0,m,n,k,1,a,k,b,n,1,c,n);
c += n*m;
state.input += l.c*l.h*l.w;
}
+
+ if(l.batch_normalize){
+ mean_cpu(l.output, l.batch, l.n, l.out_h*l.out_w, l.mean);
+ variance_cpu(l.output, l.mean, l.batch, l.n, l.out_h*l.out_w, l.variance);
+ normalize_cpu(l.output, l.mean, l.variance, l.batch, l.n, l.out_h*l.out_w);
+ }
+
activate_array(l.output, m*n*l.batch, l.activation);
}
@@ -181,8 +267,6 @@
gradient_array(l.output, m*k*l.batch, l.activation, l.delta);
backward_bias(l.bias_updates, l.delta, l.batch, l.n, k);
- if(state.delta) memset(state.delta, 0, l.batch*l.h*l.w*l.c*sizeof(float));
-
for(i = 0; i < l.batch; ++i){
float *a = l.delta + i*m*k;
float *b = l.col_image;
@@ -226,12 +310,37 @@
return float_to_image(w,h,c,l.filters+i*h*w*c);
}
+void rgbgr_filters(convolutional_layer l)
+{
+ int i;
+ for(i = 0; i < l.n; ++i){
+ image im = get_convolutional_filter(l, i);
+ if (im.c == 3) {
+ rgbgr_image(im);
+ }
+ }
+}
+
+void rescale_filters(convolutional_layer l, float scale, float trans)
+{
+ int i;
+ for(i = 0; i < l.n; ++i){
+ image im = get_convolutional_filter(l, i);
+ if (im.c == 3) {
+ scale_image(im, scale);
+ float sum = sum_array(im.data, im.w*im.h*im.c);
+ l.biases[i] += sum*trans;
+ }
+ }
+}
+
image *get_filters(convolutional_layer l)
{
image *filters = calloc(l.n, sizeof(image));
int i;
for(i = 0; i < l.n; ++i){
filters[i] = copy_image(get_convolutional_filter(l, i));
+ //normalize_image(filters[i]);
}
return filters;
}
--
Gitblit v1.10.0