From e6c97a53a7b5ac4014d30d236ea2bf5adb4bb521 Mon Sep 17 00:00:00 2001
From: AlexeyAB <alexeyab84@gmail.com>
Date: Tue, 07 Aug 2018 20:19:50 +0000
Subject: [PATCH] Maxpool fixes

---
 src/crop_layer.c |  101 +++++++++++++++++++++++++++++++++++---------------
 1 files changed, 70 insertions(+), 31 deletions(-)

diff --git a/src/crop_layer.c b/src/crop_layer.c
index e83aea2..11c59b4 100644
--- a/src/crop_layer.c
+++ b/src/crop_layer.c
@@ -2,60 +2,99 @@
 #include "cuda.h"
 #include <stdio.h>
 
-image get_crop_image(crop_layer layer)
+image get_crop_image(crop_layer l)
 {
-    int h = layer.crop_height;
-    int w = layer.crop_width;
-    int c = layer.c;
-    return float_to_image(w,h,c,layer.output);
+    int h = l.out_h;
+    int w = l.out_w;
+    int c = l.out_c;
+    return float_to_image(w,h,c,l.output);
 }
 
-crop_layer *make_crop_layer(int batch, int h, int w, int c, int crop_height, int crop_width, int flip, float angle)
+void backward_crop_layer(const crop_layer l, network_state state){}
+void backward_crop_layer_gpu(const crop_layer l, network_state state){}
+
+crop_layer make_crop_layer(int batch, int h, int w, int c, int crop_height, int crop_width, int flip, float angle, float saturation, float exposure)
 {
     fprintf(stderr, "Crop Layer: %d x %d -> %d x %d x %d image\n", h,w,crop_height,crop_width,c);
-    crop_layer *layer = calloc(1, sizeof(crop_layer));
-    layer->batch = batch;
-    layer->h = h;
-    layer->w = w;
-    layer->c = c;
-    layer->flip = flip;
-    layer->angle = angle;
-    layer->crop_width = crop_width;
-    layer->crop_height = crop_height;
-    layer->output = calloc(crop_width*crop_height * c*batch, sizeof(float));
+    crop_layer l = {0};
+    l.type = CROP;
+    l.batch = batch;
+    l.h = h;
+    l.w = w;
+    l.c = c;
+    l.scale = (float)crop_height / h;
+    l.flip = flip;
+    l.angle = angle;
+    l.saturation = saturation;
+    l.exposure = exposure;
+    l.out_w = crop_width;
+    l.out_h = crop_height;
+    l.out_c = c;
+    l.inputs = l.w * l.h * l.c;
+    l.outputs = l.out_w * l.out_h * l.out_c;
+    l.output = calloc(l.outputs*batch, sizeof(float));
+    l.forward = forward_crop_layer;
+    l.backward = backward_crop_layer;
+
     #ifdef GPU
-    layer->output_gpu = cuda_make_array(layer->output, crop_width*crop_height*c*batch);
+    l.forward_gpu = forward_crop_layer_gpu;
+    l.backward_gpu = backward_crop_layer_gpu;
+    l.output_gpu = cuda_make_array(l.output, l.outputs*batch);
+    l.rand_gpu   = cuda_make_array(0, l.batch*8);
     #endif
-    return layer;
+    return l;
 }
 
-void forward_crop_layer(const crop_layer layer, network_state state)
+void resize_crop_layer(layer *l, int w, int h)
+{
+    l->w = w;
+    l->h = h;
+
+    l->out_w =  l->scale*w;
+    l->out_h =  l->scale*h;
+
+    l->inputs = l->w * l->h * l->c;
+    l->outputs = l->out_h * l->out_w * l->out_c;
+
+    l->output = realloc(l->output, l->batch*l->outputs*sizeof(float));
+    #ifdef GPU
+    cuda_free(l->output_gpu);
+    l->output_gpu = cuda_make_array(l->output, l->outputs*l->batch);
+    #endif
+}
+
+
+void forward_crop_layer(const crop_layer l, network_state state)
 {
     int i,j,c,b,row,col;
     int index;
     int count = 0;
-    int flip = (layer.flip && rand()%2);
-    int dh = rand()%(layer.h - layer.crop_height + 1);
-    int dw = rand()%(layer.w - layer.crop_width + 1);
+    int flip = (l.flip && rand()%2);
+    int dh = rand()%(l.h - l.out_h + 1);
+    int dw = rand()%(l.w - l.out_w + 1);
     float scale = 2;
     float trans = -1;
+    if(l.noadjust){
+        scale = 1;
+        trans = 0;
+    }
     if(!state.train){
         flip = 0;
-        dh = (layer.h - layer.crop_height)/2;
-        dw = (layer.w - layer.crop_width)/2;
+        dh = (l.h - l.out_h)/2;
+        dw = (l.w - l.out_w)/2;
     }
-    for(b = 0; b < layer.batch; ++b){
-        for(c = 0; c < layer.c; ++c){
-            for(i = 0; i < layer.crop_height; ++i){
-                for(j = 0; j < layer.crop_width; ++j){
+    for(b = 0; b < l.batch; ++b){
+        for(c = 0; c < l.c; ++c){
+            for(i = 0; i < l.out_h; ++i){
+                for(j = 0; j < l.out_w; ++j){
                     if(flip){
-                        col = layer.w - dw - j - 1;    
+                        col = l.w - dw - j - 1;    
                     }else{
                         col = j + dw;
                     }
                     row = i + dh;
-                    index = col+layer.w*(row+layer.h*(c + layer.c*b)); 
-                    layer.output[count++] = state.input[index]*scale + trans;
+                    index = col+l.w*(row+l.h*(c + l.c*b)); 
+                    l.output[count++] = state.input[index]*scale + trans;
                 }
             }
         }

--
Gitblit v1.10.0