upsample_layer

Upsample Layer๋ž€?

Upsample Layer๋Š” Feature Maps์˜ ํฌ๊ธฐ๋ฅผ ํ‚ค์šฐ๋Š” Layer์ž…๋‹ˆ๋‹ค.


upsample_layer.c

forward_upsample_layer

void forward_upsample_layer(const layer l, network net)
{
    fill_cpu(l.outputs*l.batch, 0, l.output, 1);
    if(l.reverse){
        upsample_cpu(l.output, l.out_w, l.out_h, l.c, l.batch, l.stride, 0, l.scale, net.input);
    }else{
        upsample_cpu(net.input, l.w, l.h, l.c, l.batch, l.stride, 1, l.scale, l.output);
    }
}

ํ•จ์ˆ˜ ์ด๋ฆ„: forward_upsample_layer

์ž…๋ ฅ:

  • l: layer ๊ตฌ์กฐ์ฒด

  • net: network ๊ตฌ์กฐ์ฒด

๋™์ž‘:

  • ์—…์ƒ˜ํ”Œ๋ง ๋ ˆ์ด์–ด๋ฅผ ์ „๋ฐฉํ–ฅ ํŒจ์Šค(forward pass)๋กœ ์ฒ˜๋ฆฌํ•˜๋Š” ํ•จ์ˆ˜์ž…๋‹ˆ๋‹ค.

  • ์ž…๋ ฅ ์ด๋ฏธ์ง€๋ฅผ ์—…์ƒ˜ํ”Œ๋งํ•˜์—ฌ ์ถœ๋ ฅ๊ฐ’์„ ๊ณ„์‚ฐํ•ฉ๋‹ˆ๋‹ค. ์ด๋•Œ, ์ถœ๋ ฅ๊ฐ’์€ l.output์— ์ €์žฅ๋ฉ๋‹ˆ๋‹ค.

์„ค๋ช…:

  • fill_cpu() ํ•จ์ˆ˜๋Š” l.output์„ 0์œผ๋กœ ์ดˆ๊ธฐํ™”ํ•ฉ๋‹ˆ๋‹ค.

  • l.reverse๊ฐ€ ์ฐธ(True)์ผ ๊ฒฝ์šฐ, upsample_cpu() ํ•จ์ˆ˜๋ฅผ ์‚ฌ์šฉํ•˜์—ฌ l.output์— ์—…์ƒ˜ํ”Œ๋ง๋œ ์ด๋ฏธ์ง€๋ฅผ ์ €์žฅํ•ฉ๋‹ˆ๋‹ค. ์ด๋•Œ, ์ž…๋ ฅ ์ด๋ฏธ์ง€๋Š” net.input์ž…๋‹ˆ๋‹ค.

  • l.reverse๊ฐ€ ๊ฑฐ์ง“(False)์ผ ๊ฒฝ์šฐ, upsample_cpu() ํ•จ์ˆ˜๋ฅผ ์‚ฌ์šฉํ•˜์—ฌ net.input ์ด๋ฏธ์ง€๋ฅผ ์—…์ƒ˜ํ”Œ๋งํ•˜์—ฌ l.output์— ์ €์žฅํ•ฉ๋‹ˆ๋‹ค. ์ด๋•Œ, ์ถœ๋ ฅ ํฌ๊ธฐ๋Š” l.w, l.h๋กœ ์„ค์ •๋˜์–ด ์žˆ์Šต๋‹ˆ๋‹ค.

  • ์ตœ์ข…์ ์œผ๋กœ, ์ถœ๋ ฅ๊ฐ’์€ l.output์— ์ €์žฅ๋ฉ๋‹ˆ๋‹ค.

backward_upsample_layer

void backward_upsample_layer(const layer l, network net)
{
    if(l.reverse){
        upsample_cpu(l.delta, l.out_w, l.out_h, l.c, l.batch, l.stride, 1, l.scale, net.delta);
    }else{
        upsample_cpu(net.delta, l.w, l.h, l.c, l.batch, l.stride, 0, l.scale, l.delta);
    }
}

ํ•จ์ˆ˜ ์ด๋ฆ„: backward_upsample_layer

์ž…๋ ฅ:

  • l: layer ๊ตฌ์กฐ์ฒด

  • net: network ๊ตฌ์กฐ์ฒด

๋™์ž‘:

  • ์—…์ƒ˜ํ”Œ๋ง ๋ ˆ์ด์–ด์˜ ์—ญ์ „ํŒŒ(backward pass) ์—ฐ์‚ฐ์„ ์ˆ˜ํ–‰ํ•ฉ๋‹ˆ๋‹ค.

  • ์ž…๋ ฅ๊ฐ’์œผ๋กœ๋Š” l๊ณผ net์„ ๋ฐ›์œผ๋ฉฐ, l์€ ํ˜„์žฌ ๋ ˆ์ด์–ด์˜ ์ •๋ณด์™€ ์ด์ „ ๋ ˆ์ด์–ด์˜ ์ถœ๋ ฅ๊ฐ’์— ๋Œ€ํ•œ ์ •๋ณด๋ฅผ ๋‹ด๊ณ  ์žˆ์œผ๋ฉฐ, net์€ ์ „์ฒด ๋„คํŠธ์›Œํฌ์— ๋Œ€ํ•œ ์ •๋ณด๋ฅผ ๋‹ด๊ณ  ์žˆ์Šต๋‹ˆ๋‹ค.

  • ์—…์ƒ˜ํ”Œ๋ง ๋ ˆ์ด์–ด๋Š” ์ž…๋ ฅ๊ฐ’์˜ ํฌ๊ธฐ๋ฅผ ๋Š˜๋ฆฌ๋Š” ์ž‘์—…์„ ์ˆ˜ํ–‰ํ•˜๋Š”๋ฐ, ์ด๋ฅผ ์—ญ์ „ํŒŒ ํ•  ๋•Œ๋Š” ์ด์ „ ๋ ˆ์ด์–ด์˜ delta ๊ฐ’์„ ํ˜„์žฌ ๋ ˆ์ด์–ด์˜ ํฌ๊ธฐ์— ๋งž๊ฒŒ ์ถ•์†Œ(upsample)ํ•˜์—ฌ ์ „๋‹ฌํ•ฉ๋‹ˆ๋‹ค. ์ด ๊ณผ์ •์—์„œ scale ๊ฐ’์„ ์‚ฌ์šฉํ•˜์—ฌ ํฌ๊ธฐ๋ฅผ ์กฐ์ ˆํ•ฉ๋‹ˆ๋‹ค.

์„ค๋ช…:

  • ์ด ํ•จ์ˆ˜๋Š” Darknet ๋”ฅ๋Ÿฌ๋‹ ํ”„๋ ˆ์ž„์›Œํฌ์˜ ์—…์ƒ˜ํ”Œ๋ง ๋ ˆ์ด์–ด์— ๋Œ€ํ•œ ์—ญ์ „ํŒŒ ์—ฐ์‚ฐ์„ ๋‹ด๋‹นํ•ฉ๋‹ˆ๋‹ค.

  • Darknet์—์„œ๋Š” ์ž…๋ ฅ๊ฐ’์˜ ํฌ๊ธฐ๋ฅผ ๋Š˜๋ฆฌ๋Š” ์ž‘์—…์„ ์ˆ˜ํ–‰ํ•˜๋Š” ๋ฐ์— ์—…์ƒ˜ํ”Œ๋ง ๋ ˆ์ด์–ด๋ฅผ ์‚ฌ์šฉํ•˜๋ฉฐ, ์ด ๋ ˆ์ด์–ด์˜ ์ถœ๋ ฅ๊ฐ’์€ ๋‹ค์Œ ๋ ˆ์ด์–ด์˜ ์ž…๋ ฅ๊ฐ’์œผ๋กœ ์‚ฌ์šฉ๋ฉ๋‹ˆ๋‹ค. ๋”ฐ๋ผ์„œ ์ด์ „ ๋ ˆ์ด์–ด์˜ delta ๊ฐ’์„ ํ˜„์žฌ ๋ ˆ์ด์–ด์˜ ํฌ๊ธฐ์— ๋งž๊ฒŒ ์ถ•์†Œํ•˜์—ฌ ์ „๋‹ฌํ•ด์•ผ ํ•ฉ๋‹ˆ๋‹ค.

  • ์ด๋ฅผ ์œ„ํ•ด upsample_cpu() ํ•จ์ˆ˜๋ฅผ ์‚ฌ์šฉํ•˜๋ฉฐ, ์ด ํ•จ์ˆ˜์—์„œ๋Š” ์ž…๋ ฅ๊ฐ’์˜ ํฌ๊ธฐ๋ฅผ ๋Š˜๋ฆฌ๋Š” ์ž‘์—…์„ ์ˆ˜ํ–‰ํ•ฉ๋‹ˆ๋‹ค.

  • scale ๊ฐ’์„ ์‚ฌ์šฉํ•˜์—ฌ ํฌ๊ธฐ๋ฅผ ์กฐ์ ˆํ•˜๋ฉฐ, reverse ๊ฐ’์ด 1์ธ ๊ฒฝ์šฐ์—๋Š” ์ด์ „ ๋ ˆ์ด์–ด์˜ delta ๊ฐ’์„ ์ถ•์†Œํ•˜์—ฌ ์ „๋‹ฌํ•˜๊ณ , 0์ธ ๊ฒฝ์šฐ์—๋Š” net์—์„œ ์ด์ „ ๋ ˆ์ด์–ด์˜ delta ๊ฐ’์„ ๊ฐ€์ ธ์™€์„œ ํฌ๊ธฐ๋ฅผ ๋Š˜๋ฆฐ ํ›„ ํ˜„์žฌ ๋ ˆ์ด์–ด์˜ delta ๊ฐ’์œผ๋กœ ์‚ฌ์šฉํ•ฉ๋‹ˆ๋‹ค.

resize_upsample_layer

void resize_upsample_layer(layer *l, int w, int h)
{
    l->w = w;
    l->h = h;
    l->out_w = w*l->stride;
    l->out_h = h*l->stride;
    if(l->reverse){
        l->out_w = w/l->stride;
        l->out_h = h/l->stride;
    }
    l->outputs = l->out_w*l->out_h*l->out_c;
    l->inputs = l->h*l->w*l->c;
    l->delta =  realloc(l->delta, l->outputs*l->batch*sizeof(float));
    l->output = realloc(l->output, l->outputs*l->batch*sizeof(float));  
}

ํ•จ์ˆ˜ ์ด๋ฆ„: resize_upsample_layer

์ž…๋ ฅ:

  • layer *l: upsample ๋ ˆ์ด์–ด์˜ ํฌ์ธํ„ฐ

  • int w: upsample ๋ ˆ์ด์–ด์˜ ์ถœ๋ ฅ ์ด๋ฏธ์ง€ ๊ฐ€๋กœ ๊ธธ์ด

  • int h: upsample ๋ ˆ์ด์–ด์˜ ์ถœ๋ ฅ ์ด๋ฏธ์ง€ ์„ธ๋กœ ๊ธธ์ด

๋™์ž‘:

  • upsample ๋ ˆ์ด์–ด์˜ ์ถœ๋ ฅ ์ด๋ฏธ์ง€ ๊ฐ€๋กœ, ์„ธ๋กœ ๊ธธ์ด๋ฅผ ์กฐ์ ˆํ•˜๋Š” ํ•จ์ˆ˜์ด๋‹ค.

  • ์ž…๋ ฅ์œผ๋กœ ๋ฐ›์€ ๊ฐ€๋กœ, ์„ธ๋กœ ๊ธธ์ด๋กœ ๋ ˆ์ด์–ด์˜ ๊ฐ€๋กœ, ์„ธ๋กœ ๊ธธ์ด๋ฅผ ์—…๋ฐ์ดํŠธํ•˜๊ณ , ์ด๋ฅผ ๊ธฐ๋ฐ˜์œผ๋กœ ์ถœ๋ ฅ ์ด๋ฏธ์ง€ ๊ฐ€๋กœ, ์„ธ๋กœ ๊ธธ์ด๋ฅผ ๋‹ค์‹œ ๊ณ„์‚ฐํ•œ๋‹ค.

  • ๋งŒ์•ฝ ๋ ˆ์ด์–ด๊ฐ€ reverse ๋ชจ๋“œ์ด๋ฉด ์ถœ๋ ฅ ์ด๋ฏธ์ง€ ๊ฐ€๋กœ, ์„ธ๋กœ ๊ธธ์ด๋Š” ์ž…๋ ฅ ์ด๋ฏธ์ง€ ๊ฐ€๋กœ, ์„ธ๋กœ ๊ธธ์ด์— stride๋ฅผ ๋‚˜๋ˆˆ ๊ฐ’์ด ๋˜๊ณ , outputs ๊ฐ’๋„ ์ด์— ๋งž๊ฒŒ ๊ณ„์‚ฐ๋œ๋‹ค.

  • ๊ทธ๋ฆฌ๊ณ  ๋ ˆ์ด์–ด์˜ ์ž…๋ ฅ ์ฑ„๋„ ์ˆ˜์— ๋งž๊ฒŒ outputs ๊ฐ’์„ ๊ณ„์‚ฐํ•œ๋‹ค. ๋งˆ์ง€๋ง‰์œผ๋กœ delta์™€ output์„ ์—…๋ฐ์ดํŠธํ•œ๋‹ค.

์„ค๋ช…:

  • upsample ๋ ˆ์ด์–ด๋Š” ์ž…๋ ฅ ์ด๋ฏธ์ง€๋ฅผ ํ™•๋Œ€ํ•˜๋Š” ์—ญํ• ์„ ํ•œ๋‹ค. ์ด ํ•จ์ˆ˜๋Š” upsample ๋ ˆ์ด์–ด์˜ ์ถœ๋ ฅ ์ด๋ฏธ์ง€ ๊ฐ€๋กœ, ์„ธ๋กœ ๊ธธ์ด๋ฅผ ์กฐ์ •ํ•˜๋Š” ํ•จ์ˆ˜์ด๋‹ค.

  • ์ด ํ•จ์ˆ˜๋Š” l->w์™€ l->h๋ฅผ ์ž…๋ ฅ์œผ๋กœ ๋ฐ›์€ ๊ฐ€๋กœ, ์„ธ๋กœ ๊ธธ์ด๋กœ ๋ณ€๊ฒฝํ•˜๊ณ , ์ด๋ฅผ ๊ธฐ๋ฐ˜์œผ๋กœ l->out_w์™€ l->out_h๋ฅผ ๋‹ค์‹œ ๊ณ„์‚ฐํ•œ๋‹ค.

  • ์ด๋•Œ, l->out_w์™€ l->out_h๋Š” upsample ๋ ˆ์ด์–ด์˜ ์ถœ๋ ฅ ์ด๋ฏธ์ง€์˜ ๊ฐ€๋กœ, ์„ธ๋กœ ๊ธธ์ด์ด๋‹ค.

  • ๋งŒ์•ฝ upsample ๋ ˆ์ด์–ด๊ฐ€ reverse ๋ชจ๋“œ์ด๋ฉด, l->out_w์™€ l->out_h๋Š” ์ž…๋ ฅ ์ด๋ฏธ์ง€์˜ ๊ฐ€๋กœ, ์„ธ๋กœ ๊ธธ์ด์— stride๋ฅผ ๋‚˜๋ˆˆ ๊ฐ’์ด ๋œ๋‹ค.

  • ๊ทธ๋ฆฌ๊ณ  l->outputs ๊ฐ’๋„ ์ด์— ๋งž๊ฒŒ ๊ณ„์‚ฐ๋œ๋‹ค. l->outputs๋Š” upsample ๋ ˆ์ด์–ด์˜ ์ถœ๋ ฅ ์ฑ„๋„ ์ˆ˜์— ๋งž๊ฒŒ ์ถœ๋ ฅ ์ด๋ฏธ์ง€์˜ ํ”ฝ์…€ ์ˆ˜๋ฅผ ๋‚˜ํƒ€๋‚ธ๋‹ค.

  • ๋งˆ์ง€๋ง‰์œผ๋กœ delta์™€ output์„ ์—…๋ฐ์ดํŠธํ•˜์—ฌ ๋ฉ”๋ชจ๋ฆฌ๋ฅผ ํ• ๋‹นํ•œ๋‹ค.

make_upsample_layer

layer make_upsample_layer(int batch, int w, int h, int c, int stride)
{
    layer l = {0};
    l.type = UPSAMPLE;
    l.batch = batch;
    l.w = w;
    l.h = h;
    l.c = c;
    l.out_w = w*stride;
    l.out_h = h*stride;
    l.out_c = c;
    if(stride < 0){
        stride = -stride;
        l.reverse=1;
        l.out_w = w/stride;
        l.out_h = h/stride;
    }
    l.stride = stride;
    l.outputs = l.out_w*l.out_h*l.out_c;
    l.inputs = l.w*l.h*l.c;
    l.delta =  calloc(l.outputs*batch, sizeof(float));
    l.output = calloc(l.outputs*batch, sizeof(float));;

    l.forward = forward_upsample_layer;
    l.backward = backward_upsample_layer;

    if(l.reverse) fprintf(stderr, "downsample         %2dx  %4d x%4d x%4d   ->  %4d x%4d x%4d\n", stride, w, h, c, l.out_w, l.out_h, l.out_c);
    else fprintf(stderr, "upsample           %2dx  %4d x%4d x%4d   ->  %4d x%4d x%4d\n", stride, w, h, c, l.out_w, l.out_h, l.out_c);
    return l;
}

ํ•จ์ˆ˜ ์ด๋ฆ„: make_upsample_layer

์ž…๋ ฅ:

  • batch: int ํ˜•์‹์˜ ๋ฐฐ์น˜ ํฌ๊ธฐ

  • w: int ํ˜•์‹์˜ ์ž…๋ ฅ ๋„ˆ๋น„

  • h: int ํ˜•์‹์˜ ์ž…๋ ฅ ๋†’์ด

  • c: int ํ˜•์‹์˜ ์ž…๋ ฅ ์ฑ„๋„ ์ˆ˜

  • stride: int ํ˜•์‹์˜ ์—…์ƒ˜ํ”Œ๋ง ๋ฐฐ์œจ ๋˜๋Š” ๋‹ค์šด์ƒ˜ํ”Œ๋ง ๋ฐฐ์œจ(์Œ์ˆ˜)

๋™์ž‘:

  • ์ž…๋ ฅ์œผ๋กœ ๋ฐ›์€ batch, w, h, c, stride ๊ฐ’์„ ์‚ฌ์šฉํ•˜์—ฌ upsample ๋ ˆ์ด์–ด๋ฅผ ์ƒ์„ฑํ•œ๋‹ค.

  • stride ๊ฐ’์ด ์Œ์ˆ˜์ธ ๊ฒฝ์šฐ ๋‹ค์šด์ƒ˜ํ”Œ๋ง์œผ๋กœ ๋™์ž‘ํ•œ๋‹ค.

  • ๋ ˆ์ด์–ด์˜ ์ถœ๋ ฅ ํฌ๊ธฐ(out_w, out_h, out_c)์™€ ์ถœ๋ ฅ ์š”์†Œ ์ˆ˜(outputs)๋ฅผ ๊ณ„์‚ฐํ•œ๋‹ค.

  • ๋ ˆ์ด์–ด์˜ ์ž…๋ ฅ ์š”์†Œ ์ˆ˜(inputs), ๋ธํƒ€(delta), ์ถœ๋ ฅ(output)์„ ๋ฉ”๋ชจ๋ฆฌ์— ํ• ๋‹นํ•˜๊ณ , 0์œผ๋กœ ์ดˆ๊ธฐํ™”ํ•œ๋‹ค.

  • ์—…์ƒ˜ํ”Œ๋ง ๋ ˆ์ด์–ด์˜ forward์™€ backward ํ•จ์ˆ˜๋ฅผ ์„ค์ •ํ•œ๋‹ค.

  • ์—…์ƒ˜ํ”Œ๋ง ๋ ˆ์ด์–ด์˜ ์ •๋ณด๋ฅผ ์ถœ๋ ฅํ•œ๋‹ค.

์„ค๋ช…:

  • ์—…์ƒ˜ํ”Œ๋ง ๋ ˆ์ด์–ด๋ฅผ ๋งŒ๋“œ๋Š” ํ•จ์ˆ˜์ด๋‹ค.

  • ์ด ํ•จ์ˆ˜์—์„œ ์ƒ์„ฑ๋œ ๋ ˆ์ด์–ด๋Š” ์ž…๋ ฅ ์ด๋ฏธ์ง€๋ฅผ upsample ๋˜๋Š” downsampleํ•˜์—ฌ ์ถœ๋ ฅํ•˜๋Š” ์—ญํ• ์„ ํ•œ๋‹ค.

  • ์ž…๋ ฅ ์ด๋ฏธ์ง€์˜ ํฌ๊ธฐ๋ฅผ ํ‚ค์šฐ๋Š” upsample๊ณผ ํฌ๊ธฐ๋ฅผ ์ค„์ด๋Š” downsample์ด ์žˆ๋‹ค.

  • ์ด ํ•จ์ˆ˜์—์„œ๋Š” stride ๊ฐ’์„ ์ด์šฉํ•˜์—ฌ upsample๊ณผ downsample์„ ๊ตฌ๋ถ„ํ•˜๊ณ , ์—ญ์ „ํŒŒ ํ•จ์ˆ˜์—์„œ ํ•ด๋‹น ์—ฐ์‚ฐ์„ ์ฒ˜๋ฆฌํ•œ๋‹ค.

  • ๋ ˆ์ด์–ด์˜ ์ถœ๋ ฅ ํฌ๊ธฐ๋Š” ์ž…๋ ฅ ํฌ๊ธฐ์™€ stride ๊ฐ’์— ๋”ฐ๋ผ ๊ฒฐ์ •๋œ๋‹ค.

  • ์ด ํ•จ์ˆ˜์—์„œ๋Š” ๋ฉ”๋ชจ๋ฆฌ ํ• ๋‹น๊ณผ ์ดˆ๊ธฐํ™”๋ฅผ ์ˆ˜ํ–‰ํ•˜๊ณ , forward์™€ backward ํ•จ์ˆ˜๋ฅผ ์„ค์ •ํ•˜๋Š” ์ž‘์—…์„ ํ•œ๋‹ค.

Last updated

Was this helpful?