์ธ๊ณต์ง€๋Šฅ ์ •๋ฆฌ [๋ณธ๋ก 3] :: ํ•™์Šต (feat. weight์˜ ์กฐ์ •)

weight์˜ ๋ณ€ํ™”

1. ๋žœ๋ค

์‹ค์Šต

one-layer perceptron

weight๋ฅผ ๋žœ๋ค์œผ๋กœ ํ•™์Šตํ•˜๋Š” ํผ์…‰ํŠธ๋ก  ๋งŒ๋“ค๊ธฐ

input, weight ๊ฐฏ์ˆ˜๋Š” ์ž…๋ ฅ๋ฐ›๊ธฐ

output์€ 1๊ฐœ๋กœ ๊ณ ์ •

/*
    2020-01-28 W.HE
one-layer perceptron
*/

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

main() {
    /* variable set */
    int input_num;
    float* input;
    float* w;
float output = 0;
    float answer = 3;
    int try_num = 0;

    /* input input_num */
    printf("enter number of inputs\n");
    scanf_s("%d", &input_num);

    /* memory allocation */
    input = (float*)malloc(sizeof(int)*input_num);
    w = (float*)malloc(sizeof(int)*input_num);

    /* input */
    printf("enter inputs\n");
    int n_tmp = 0;

    while (input_num != n_tmp) {
        printf("%d๋ฒˆ์งธ input : ", n_tmp + 1);
        scanf_s("%f", input + n_tmp++);
    }

    /*
    input ์ž…๋ ฅ ํ™•์ธ
    for (int i = 0; i < input_num; i++) {
        printf("%lf ", *(input + i));
    }
    */

    while (output-answer<1 || output-answer>-1) { // error๊ฐ€ 1 ์ดํ•˜์ผ ๋•Œ๊นŒ์ง€

        /* random w (0~1) */
        srand(time(NULL));
        for (int i = 0; i < input_num; i++) {
            w[i] = rand() % 10;
            w[i] = 0.1*w[i];
            // w ํ™•์ธ 
            // printf("%lf ", w[i]);
        }

        /* perceptron */
        for (int i = 0; i < input_num; i++) {
            output += w[i] * input[i];
        }

        printf("try number : %d\n", ++try_num);
        printf("output : %lf\n", output);
        printf("error : %lf\n\n", output-answer);
    }

    getch();
}

๋ฌธ์ œ์  : ๋ฐœ์‚ฐํ•˜๋Š” ๊ฒฝ์šฐ๊ฐ€ ํ—ˆ๋‹คํ•˜๊ณ  ํŠน์ •ํ•œ ์•Œ๊ณ ๋ฆฌ์ฆ˜ ์—†์ด ๊ทธ์ € ์ถ”์ธก๋งŒ ๋ฐ˜๋ณตํ•  ๋ฟ์ด๋‹ค.

error ๊ฐ’์— ๋”ฐ๋ผ w ๊ฐ’์ด ์กฐ์ •์ด ๋˜์–ด์•ผํ•œ๋‹ค.

์–ด์ฐจํ”ผ Error๋Š” x,w ๋‘ ๋ณ€์ˆ˜์— ๋Œ€ํ•œ ์‹์ด๋ฏ€๋กœ x๊ฐ€ ๊ณ ์ •๋˜์–ด์žˆ์„ ๋•Œ w๋ผ๋Š” ํ•œ ๋ณ€์ˆ˜๋กœ ๋‚˜ํƒ€๋‚ผ ์ˆ˜ ์žˆ์Œ

์‚ฌ์‹ค์€ w๊ฐ€ w1,w2, ... ์ธ ๋ฐฐ์—ด์ด๊ธดํ•˜๋‹ค. ( ํ•˜๋‚˜ํ•˜๋‚˜์”ฉ ๋ณด๋ฉด ์œ„์™€ ๊ฐ™๋‹ค๋Š” ์ด์•ผ๊ธฐ )

์ฆ‰, ์ „์ฒด w๊ฐ’์— ๋Œ€ํ•ด ๋‚˜ํƒ€๋‚ด๋ ค๋ฉด n์ฐจ์›์˜ ๊ทธ๋ž˜ํ”„๊ฐ€ ํ•„์š”ํ•˜์ง€๋งŒ ์‰ฝ๊ฒŒ ์ดํ•ดํ•˜๊ธฐ ์œ„ํ•ด ์•„๋ž˜์˜ ๊ทธ๋ž˜ํ”„๋“ค์€ ํ•˜๋‚˜์˜ w๊ฐ’์— ๋Œ€ํ•ด์„œ error ๊ฐ’์˜ ๋ณ€ํ™”๋ฅผ ๋‚˜ํƒ€๋‚ด๋Š” 2์ฐจ์› ๊ทธ๋ž˜ํ”„์ด๋‹ค.

๋”ฐ๋ผ์„œ w์™€ error์— ๋Œ€ํ•œ ๊ทธ๋ž˜ํ”„๋กœ ๋‚˜ํƒ€๋‚ด๋ณด์•˜๋‹ค.

์ฃผํ™ฉ์ƒ‰ ์ ์ด ํ˜„์žฌ์˜ error๋ผ๊ณ  ํ•˜๋ฉด, weight๊ฐ€ ๋žœ๋ค์œผ๋กœ ์ดˆ๊ธฐํ™”๋  ๋•Œ๋งˆ๋‹ค output์ด ๋‹ฌ๋ผ์ง€๋ฉด์„œ error๊ฐ€ 1๋ณด๋‹ค ์ž‘์„ ๋•Œ๊นŒ์ง€ ๋ฌดํ•œ ๋ฐ˜๋ณตํ•˜๊ฒŒ๋œ๋‹ค.

2. w๊ฐ’ ์กฐ์ •

  1. ์กฐ๊ธˆ์”ฉ ์˜ฎ๊ฒจ๋ณด๊ธฐ


    w๊ฐ’์„ ์•„์ฃผ ์กฐ๊ธˆ์”ฉ ์˜ฎ๊ฒจ๋ณด๋ฉด์„œ error๊ฐ€ ๊ฐ์†Œํ•˜๋Š” ๋ฐฉํ–ฅ์œผ๋กœ ์ด๋™ํ•˜๋Š” ๋ฐฉ๋ฒ•์ด๋‹ค.

    ๊ทธ๋ฆผ์—์„œ 1=>2๋กœ ๊ฐ€๋ฉด error๊ฐ€ ์ฆ๊ฐ€ํ•˜์ง€๋งŒ, 1=>3์œผ๋กœ ๊ฐ€๋ฉด error๊ฐ€ ๊ฐ์†Œํ•˜๋ฏ€๋กœ 1=>3๋กœ ๊ฐ€๋Š” w๊ฐ’์˜ ๋ณ€ํ™”๋ฅผ ํƒํ•ด์„œ ์ ์šฉํ•œ๋‹ค.

    ํ•˜์ง€๋งŒ ์œ„์˜ ๊ทธ๋ฆผ์—์„œ๋Š” error ๊ฐ’์ด 1๋ณด๋‹ค ์ž‘์•„์งˆ ์ˆ˜ ์—†์œผ๋ฏ€๋กœ ์ •๋‹ต์„ ์ฐพ์„ ์ˆ˜ ์—†๋‹ค.

    ์ด๋Ÿฌํ•œ ๋ฌธ์ œ๊ฐ€ ์ผ์–ด๋‚˜๋Š” ์ด์œ ๋Š” ์œ„์˜ ๊ทธ๋ž˜ํ”„์—์„œ ์ตœ์†Œ์ (global minimum)์ด ์•„๋‹Œ ๊ทน์†Œ์ (local minimum)์„ ์ฐพ๊ธฐ ๋•Œ๋ฌธ์ธ๋ฐ ๋‚˜์ค‘์— ์ด๋ฅผ ๊ทน๋ณตํ•  ์ˆ˜ ์žˆ๋Š” ๋ฐฉ๋ฒ•์ด ๋‚˜์˜จ๋‹ค.

  2. ๋ฏธ๋ถ„ ์ด์šฉํ•˜๊ธฐ

    w์— ๋Œ€ํ•œ error์˜ ๋ฏธ๋ถ„์„ ๊ตฌํ•˜๋ฉด error๊ฐ€ ๋‚ฎ์•„์ง€๋Š” ๋ฐฉํ–ฅ์„ ์•Œ ์ˆ˜ ์žˆ๋‹ค.

๊ทธ๋ฆผ 1์—์„œ ํ˜„์žฌ w๊ฐ’์— ๋Œ€ํ•œ error ๊ทธ๋ž˜ํ”„์˜ ๊ธฐ์šธ๊ธฐ๊ฐ€ +์ด๋ฏ€๋กœ,

error ๊ฐ’์ด ์ž‘์•„์ง€๊ธฐ ์œ„ํ•ด์„œ๋Š” ๊ธฐ์šธ๊ธฐ์˜ ๋ฐ˜๋Œ€ ๋ถ€ํ˜ธ์ธ -์ชฝ์œผ๋กœ w๊ฐ’์ด ์ด๋™ํ•˜์—ฌ์•ผํ•œ๋‹ค.

๋”ฐ๋ผ์„œ, w๊ฐ’์—์„œ error๊ฐ’์œผ๋กœ ๊ณ„์‚ฐํ•œ ์–ด๋– ํ•œ ์ˆ˜๋ฅผ ๋นผ์„œ ์ƒˆ๋กœ์šด w๊ฐ’์œผ๋กœ ๋‹ค์‹œ net์„ ๊ตฌํ•˜๊ณ  output์„ ๊ตฌํ•˜๊ณ  error๊ฐ’์„ ๊ตฌํ•ด์•ผํ•œ๋‹ค. (์ฆ‰, perceptron์—์„œ forward propagation์„ ํ•ด์•ผํ•œ๋‹ค.)

ํ•˜์ง€๋งŒ ์ด๋Ÿฌํ•œ ๊ฒฝ์šฐ์—๋„ ๊ทน์†Œ์ (local minimum)์— ๋น ์งˆ ์ˆ˜ ์žˆ๋Š” ์œ„ํ—˜์€ ์œ„์˜ ๊ฒฝ์šฐ์™€ ๊ฐ™์ด ์กด์žฌํ•œ๋‹ค.

๋‹ค๋ฅธ ๊ด€์  (์ฐธ๊ณ )

x์— ๋”ฐ๋ฅธ error์˜ ๊ทธ๋ž˜ํ”„๋Š” ๋‚˜ํƒ€๋‚ผ ํ•„์š”๊ฐ€ ์—†๋‹ค.

ํ•ญ์ƒ error๊ฐ€ 0์ธ ๊ฒƒ์ด ์ •๋‹ต์ด๊ธฐ ๋•Œ๋ฌธ์—, ์ƒ์ˆ˜ 0์˜ ๊ทธ๋ž˜ํ”„๊ฐ€ ๋‚˜์˜ด

๊ทธ๋ ‡๋‹ค๋ฉด x์— ๋”ฐ๋ฅธ output์˜ ๊ทธ๋ž˜ํ”„๋ฅผ ๋‚˜ํƒ€๋‚ด์„œ output์— ๊ฐ€๊นŒ์›Œ์ง€๊ธฐ ์œ„ํ•œ w๊ฐ’์˜ ์กฐ์ •์„ ์‚ดํŽด๋ณด์ž.

์—ฌ๊ธฐ์„œ๋„ x๋Š” x1,x2,... ๋“ฑ ๋ฌด์ˆ˜ํžˆ ๋งŽ์„ ์ˆ˜ ์žˆ์ง€๋งŒ ์ดํ•ด๋ฅผ ๋•๊ธฐ ์œ„ํ•ด ํ•˜๋‚˜์˜ x ๊ฐ’์— ๋Œ€ํ•ด์„œ๋งŒ ๊ทธ๋ž˜ํ”„๋ฅผ ๋‚˜ํƒ€๋‚ด์—ˆ๋‹ค.

output์€ f(net)์ด๊ณ  ์ฆ‰, f(w*x์˜ ํ•ฉ)์ด๋ฏ€๋กœ ํ•˜๋‚˜์˜ w*x๋งŒ์„ ๋ณผ ๋•Œ

w๋Š” ์ •ํ•ด์ง„ x(input)์„ ํ†ต๊ณผํ•˜๋Š” ์ง์„ ์˜ ๊ธฐ์šธ๊ธฐ์ด๋‹ค.

๋”ฐ๋ผ์„œ, ์ฃผ์–ด์ง„ input๋งŒ์ด ์•„๋‹ˆ๋ผ ๋ชจ๋“  x์— ๋Œ€ํ•ด์„œ error( answer - output )๋ฅผ ์ ๊ฒŒ ํ•˜๋ ค๋ฉด ์ •๋‹ต ๊ทธ๋ž˜ํ”„์™€ ์ด ์ง์„ ๊ฐ„์˜ ๊ฑฐ๋ฆฌ๊ฐ€ ๊ฐ€๊นŒ์›Œ์•ผํ•œ๋‹ค.

๊ฒฐ๋ก ์ ์œผ๋กœ x๋ฅผ ํ†ต๊ณผํ•˜๋Š” ์ง์„ ์˜ ๊ธฐ์šธ๊ธฐ w๋ฅผ ์ „์ฒด error๊ฐ€ ๋‚ฎ์•„์ง€๋Š” ๋ฐฉํ–ฅ์œผ๋กœ ์กฐ์ •ํ•ด์•ผํ•œ๋‹ค๋Š” ๊ฒƒ์ด๋‹ค.

์ด๋ฅผ ์ข€ ๋” ๊ตฌ์ฒด์ ์œผ๋กœ ์‚ดํŽด๋ณด๊ธฐ ์œ„ํ•ด input์ด 2๊ฐœ์ธ ๊ฒฝ์šฐ๋ฅผ ๊ฐ€์ •ํ•˜์—ฌ, x1,x2์— ๋Œ€ํ•œ output์˜ ๊ทธ๋ž˜ํ”„๋กœ ๋‚˜ํƒ€๋‚ด๋ณด์ž.

๋‚˜์™€์žˆ๋Š” ๊ตฌ๋“ค์€ ๋ชจ๋‘ ์ •๋‹ต์„ ๋‚˜ํƒ€๋‚ธ ๊ฒƒ์ด๋‹ค.

์ •๋‹ต๊ณผ ๊ฐ€๊นŒ์šด output์„ ๋งŒ๋“ค์–ด์•ผํ•˜๋Š”๋ฐ,

์šฐ์„  net์€ ํ˜„์žฌ w1*x1+w2*x2+B์ด๋‹ค.

์—ฌ๊ธฐ์„œ B๋Š” ์šฐ์„  ์ƒ์ˆ˜๋ผ๊ณ  ์ƒ๊ฐํ•˜๋ฉด ๋œ๋‹ค. (B๋„ learning์˜ ๋Œ€์ƒ์ด๋‹ค.)

net์ด activation function์„ ๊ฑฐ์ณ output์œผ๋กœ ๋‚˜ํƒ€๋‚˜๊ฒŒ ๋˜๋Š”๋ฐ

output = f(net)

์—ฌ๊ธฐ์„œ ์‚ฌ์šฉํ•œ activation function์€

์ด์™€ ๊ฐ™์€ threshold function์ด๋‹ค.

์ด์ œ ํ•™์Šต์˜ ๋Œ€์ƒ์ธ w1, w2๋ฅผ ์กฐ์ •ํ•˜์—ฌ ์ด์™€ ๊ฐ™์€ activation function์ด answer๋ฅผ ๋งŒ์กฑํ•˜๋„๋ก ๋งŒ๋“ค๋ฉด ๋œ๋‹ค.

์‰ฝ๊ฒŒ ์ƒ๊ฐํ•ด์„œ net์ด๋ผ๋Š” ์ง์„ ์œผ๋กœ x1, x2 ์ถ•์œผ๋กœ ๋œ 2์ฐจ์› ์ƒ์—์„œ ๊ฐ™์€ output์„ ๊ฐ–๋Š” ์ ๋“ค์„ ๋ถ„๋ฆฌํ•  ์ˆ˜ ์žˆ์œผ๋ฉด ๋œ๋‹ค.

ํ‰๋ฉด์ ์œผ๋กœ ๋‚˜ํƒ€๋‚ด๋ฉด ์ด๋Ÿฌํ•˜๋‹ค.

์˜ˆ๋ฅผ ๋“ค์–ด ์œ„์™€ ๊ฐ™์€ ๊ฒฝ์šฐ (0,1)์—์„œ 0์ด ์•„๋‹Œ 1์˜ output์ด ๋‚˜์˜ค๋„๋ก net์ด ๊ตฌ์„ฑ๋˜์–ด์žˆ์œผ๋ฏ€๋กœ error๊ฐ€ ์ปค์ง„๋‹ค.

์—ฌ๊ธฐ์„œ ๋ฌธ์ œ๋ฅผ ํ•˜๋‚˜ ๋ฐœ๊ฒฌํ•  ์ˆ˜ ์žˆ๋Š”๋ฐ, (1,1,1)์ด๋ผ๋Š” ์ ์ด ์ƒ๊ธฐ๋ฉด ์–ด๋–ป๊ฒŒ ํ•ด๊ฒฐํ•˜๋ƒ๋Š” ๊ฒƒ์ด๋‹ค.

์ด ๊ฒฝ์šฐ ์ฐจ์›์„ ํ•˜๋‚˜๋Š˜๋ ค 4์ฐจ์› ์ƒ์—์„œ ์ƒ๊ฐํ•˜๊ฑฐ๋‚˜

input์„ ํ•˜๋‚˜ ์ถ”๊ฐ€ํ•˜์—ฌ x3๋ฅผ ๋งŒ๋“ ๋‹ค.

๊ทธ๋Ÿฌ๋ฉด x1,x2,x3์˜ 3์ฐจ์› ์ƒ์—์„œ ํ‰๋ฉด์ธ net์ด ์ ๋“ค์„ ๋ถ„๋ฆฌํ•  ์ˆ˜ ์žˆ๋‹ค.

์ฃผ์–ด์ง„ ์ฐจ์›์„ ๋ณ€ํ™˜ํ•˜์—ฌ 3์ฐจ์›์—์„œ ํ•ด๊ฒฐํ•  ์ˆ˜ ์žˆ๋Š” ํ˜•ํƒœ๋กœ ๋ฐ”๊พธ๋Š” ๋ฐฉ๋ฒ•์ด ์žˆ๋‹ค.

layer๋ฅผ ํ•˜๋‚˜ ์ถ”๊ฐ€ํ•˜์—ฌ multi-layer perceptron์„ ๋งŒ๋“ ๋‹ค.

๊ทธ๋ฆผ์œผ๋กœ ๋‚˜ํƒ€๋‚ด์ž๋ฉด,

์ด์™€ ๊ฐ™์€ ๊ธฐ์กด์˜ perceptron์„

input์„ ํ•˜๋‚˜ ์ถ”๊ฐ€ํ•˜๊ฑฐ๋‚˜

layer๋ฅผ ํ•˜๋‚˜ ๋Š˜๋ฆฌ๋Š” ๋ฐฉ๋ฒ•์œผ๋กœ ๋ฐ”๊พธ์–ด์•ผ ํ•œ๋‹ค.

์—ฌ๊ธฐ์„œ layer๋ž€

node(๋‰ด๋Ÿฐ์„ธํฌ) ๋“ค์ด ์ด๋ฃจ๋Š” ํ•˜๋‚˜์˜ ์ธต์ด๋‹ค.

input node ๋“ค๋กœ ์ด๋ฃจ์–ด์ ธ์žˆ๋Š” layer๋Š” input layer์ด๋ฉฐ, input์—์„œ ์ตœ์ข… output์ด ๋‚˜์˜ฌ ๋•Œ๊นŒ์ง€ ์ค‘๊ฐ„๊ณผ์ •์ด์ž ๊ฒ‰์œผ๋กœ ๋“œ๋Ÿฌ๋‚˜์ง€ ์•Š๋Š” layer๋ฅผ hidden layer๋ผ๊ณ  ํ•œ๋‹ค.

์ด ์ธต์ด ๊นŠ์–ด์ง„ perceptron์„ deep neural networks (multi-layer perceptron)๋ผ๊ณ  ํ•˜๋Š”๋ฐ, ์ด๋Š” ๋ณต์žกํ•œ ๋ฌธ์ œ๊ฐ€ layer๋ฅผ ๊ฑฐ์น  ์ˆ˜๋ก ๋‚ฎ์€ ์ฐจ์›์—์„œ ํ•ด๊ฒฐํ•  ์ˆ˜ ์žˆ๋Š” ๊ฐ„๋‹จํ•œ ๋ฌธ์ œ๋กœ ๋ณ€ํ™˜๋  ์ˆ˜ ์žˆ๊ธฐ ๋•Œ๋ฌธ์— ์œ ์šฉํ•˜๋‹ค. ์ด๋Ÿฌํ•œ deep neural network๋ฅผ ์ด์šฉํ•˜๋Š” ๋จธ์‹ ๋Ÿฌ๋‹์„ ๋”ฅ๋Ÿฌ๋‹์ด๋ผ๊ณ  ํ•œ๋‹ค.

๋ฐ˜์‘ํ˜•