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๊ฐ ์กฐ์
-
์กฐ๊ธ์ฉ ์ฎ๊ฒจ๋ณด๊ธฐ
w๊ฐ์ ์์ฃผ ์กฐ๊ธ์ฉ ์ฎ๊ฒจ๋ณด๋ฉด์ error๊ฐ ๊ฐ์ํ๋ ๋ฐฉํฅ์ผ๋ก ์ด๋ํ๋ ๋ฐฉ๋ฒ์ด๋ค.
๊ทธ๋ฆผ์์ 1=>2๋ก ๊ฐ๋ฉด error๊ฐ ์ฆ๊ฐํ์ง๋ง, 1=>3์ผ๋ก ๊ฐ๋ฉด error๊ฐ ๊ฐ์ํ๋ฏ๋ก 1=>3๋ก ๊ฐ๋ w๊ฐ์ ๋ณํ๋ฅผ ํํด์ ์ ์ฉํ๋ค.
ํ์ง๋ง ์์ ๊ทธ๋ฆผ์์๋ error ๊ฐ์ด 1๋ณด๋ค ์์์ง ์ ์์ผ๋ฏ๋ก ์ ๋ต์ ์ฐพ์ ์ ์๋ค.
์ด๋ฌํ ๋ฌธ์ ๊ฐ ์ผ์ด๋๋ ์ด์ ๋ ์์ ๊ทธ๋ํ์์ ์ต์์ (global minimum)์ด ์๋ ๊ทน์์ (local minimum)์ ์ฐพ๊ธฐ ๋๋ฌธ์ธ๋ฐ ๋์ค์ ์ด๋ฅผ ๊ทน๋ณตํ ์ ์๋ ๋ฐฉ๋ฒ์ด ๋์จ๋ค.
-
๋ฏธ๋ถ ์ด์ฉํ๊ธฐ
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๋ฅผ ์ด์ฉํ๋ ๋จธ์ ๋ฌ๋์ ๋ฅ๋ฌ๋์ด๋ผ๊ณ ํ๋ค.
'์ปดํจํฐ๊ณผํ (CS) > AI' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
์ธ๊ณต์ง๋ฅ ์ ๋ฆฌ [๋ถ๋ก] :: Restricted Boltzmann Machine (RBM) (0) | 2020.02.08 |
---|---|
์ธ๊ณต์ง๋ฅ ์ ๋ฆฌ [๋ณธ๋ก 4] :: ๋ฅ๋ฌ๋์ ์์ (0) | 2020.02.01 |
์ธ๊ณต์ง๋ฅ ์ ๋ฆฌ [๋ณธ๋ก 2] :: ์ ๊ฒฝ๋ง ํ์ต (0) | 2020.01.31 |
์ธ๊ณต์ง๋ฅ ์ ๋ฆฌ [๋ณธ๋ก 1] :: ์ธ๊ณต์ง๋ฅ์ ๋ชฉํ (0) | 2020.01.29 |
์ธ๊ณต์ง๋ฅ ์ ๋ฆฌ [์๋ก ] :: ์ธ๊ณต์ง๋ฅ์ด๋? (0) | 2020.01.29 |
Comment