지노랩 /JinoLab

21. Deep Learning을 위한 미분(calculus)

지노랩/JinoLab — Sat, 16 Aug 2025 09:21:14 +0900

1. 미분이 뭐예요?

함수 f(x)의 미분은 “함수 값이 얼마나 빨리 변하는지”를 나타내는 수학적 도구예요.
기하학적으로는 접선의 기울기를 뜻해요.

즉, x를 아주 조금 Δx 만큼 바꿨을 때, f가 얼마나 변하는지( Δf )를 Δx로 나누면, 그 비율이 미분값이에요.

2. 주요 미분 공식

상수배 법칙

상수 cc는 그대로 밖으로 나온다!

거듭제곱 법칙 (Power Rule)

합의 법칙

차의 법칙 (합과 같음)

곱의 법칙 (Product Rule)

체인 룰 (Chain Rule)

3. 접선 기울기 계산 예시

예: f(x) = 3x 일 때, x=2에서 기울기는 항상 3! (직선이라 일정)
예: g(x) = x^2 일 때, g′(x) = 2x 이므로, x = 3에서 기울기는 2⋅3 = 6

4. C 언어로 “수치 미분(Numerical Derivative)” 구현하기

실제 딥러닝 라이브러리는 자동으로 미분을 계산해 주지만, 개념을 잡기 위해 작은 변화 Δx\Delta x 를 이용한 근사 미분 코드를 만들어 봅시다.

#include <stdio.h>

// 예시 함수 1: f(x) = 3x
double f1(double x) {
    return 3.0 * x;
}

// 예시 함수 2: f(x) = x^2
double f2(double x) {
    return x * x;
}

// 예시 함수 3: h(x) = (3x + 2x^2)^2
double h(double x) {
    double u = 3.0*x + 2.0*x*x;
    return u * u;
}

// 수치 미분: (f(x+h) - f(x)) / h
double numerical_derivative(double (*func)(double), double x) {
    double h = 1e-6;  // 매우 작은 값
    return (func(x + h) - func(x)) / h;
}

int main(void) {
    double x;

    // f1 미분
    x = 2.0;
    printf("f1(x)=3x,  x=%.2f -> f'(x)≈%.6f  (정답=3.0)\n",
           x, numerical_derivative(f1, x));

    // f2 미분
    x = 3.0;
    printf("f2(x)=x^2, x=%.2f -> f'(x)≈%.6f  (정답=2x=6.0)\n",
           x, numerical_derivative(f2, x));

    // h 미분 (체인룰 예시)
    x = 1.0;
    printf("h(x)=(3x+2x^2)^2, x=%.2f -> h'(x)≈%.6f  (정답=2u·u' = 2*(3+2)* (3+4*1) = 2*5*7=70)\n",
           x, numerical_derivative(h, x));

    return 0;
}

어떻게 동작하나요?

작은 h (10^-6)를 더한 뒤 함수 값을 구하고, 원래 값과 빼서 Δf를 얻어요.
Δf를 Δx로 나누면 미분값을 근사할 수 있습니다.
실제 수학 식으로 미분한 결과(3.0, 6.0, 70.0)와 아주 가까운 값을 확인할 수 있어요.

마무리

딥러닝에서 역전파(Backpropagation) 와 경사하강법(Gradient Descent) 에는 이 미분 개념이 숨어 있어요.
오늘 배운 미분 공식을 잘 이해하면, 다음 시간에 “오차를 줄이는 방향”을 계산할 때 수식이 더 명확하게 다가올 거예요!

20. “근육량 예측 신경망”의 순전파(Forward Propagation) 과정을 C 언어로

지노랩/JinoLab — Fri, 15 Aug 2025 09:08:18 +0900

데이터 정규화
가중치 초기화(예시로 임의값 사용)
첫 번째 학습 예제 순전파
중간값(z), 활성화(a), 출력(ŷ) 계산

1. 문제 정의

입력 (x1,x2) = (운동시간, 휴식시간)
출력 y = 근육량 증가(grams)
신경망 구조
- 입력층: 2개 노드
- 은닉층: 3개 노드 (활성화: ReLU)
- 출력층: 1개 노드 (활성화: Sigmoid)

2. 코드 전체

#include <stdio.h>
#include <math.h>

// --- 활성화 함수들 ---
double relu(double z) {
    return z > 0 ? z : 0;
}
double sigmoid(double z) {
    return 1.0 / (1.0 + exp(-z));
}

// --- 순전파 함수 ---
// X: (m×n) 입력 행렬, W1: (n×h) 은닉 가중치, W2: (h×1) 출력 가중치
// m=샘플 개수(여기선 3), n=피처 수(2), h=은닉 노드 수(3)
void forward(int m, int n, int h,
             double X[m][n],
             double W1[n][h],
             double W2[h][1],
             double Yhat[m])
{
    for (int i = 0; i < m; i++) {
        // 1) 은닉층 z2 = X[i] · W1  (1×n)·(n×h) → (1×h)
        double z2[ h ];
        for (int j = 0; j < h; j++) {
            z2[j] = 0;
            for (int k = 0; k < n; k++) {
                z2[j] += X[i][k] * W1[k][j];
            }
        }
        // 2) 은닉층 a2 = ReLU(z2)
        double a2[ h ];
        for (int j = 0; j < h; j++) {
            a2[j] = relu(z2[j]);
        }
        // 3) 출력층 z3 = a2 · W2  (1×h)·(h×1) → (1×1)
        double z3 = 0;
        for (int j = 0; j < h; j++) {
            z3 += a2[j] * W2[j][0];
        }
        // 4) 예측값 yhat = sigmoid(z3)
        Yhat[i] = sigmoid(z3);
    }
}

int main(void) {
    // --- 1) 원본 데이터 (m=3 샘플) ---
    // [운동시간, 휴식시간]
    double rawX[3][2] = {
        {2.0, 8.0},
        {5.0, 5.0},
        {1.0, 8.0}
    };
    // 근육량 증가(grams)
    double rawY[3] = {291.0, 920.0, 190.0};

    // --- 2) 정규화 (0~1) ---
    double maxX0 = 5.0, maxX1 = 8.0, maxY = 920.0;
    double X[3][2], Y[3];
    for (int i = 0; i < 3; i++) {
        X[i][0] = rawX[i][0] / maxX0;
        X[i][1] = rawX[i][1] / maxX1;
        Y[i]    = rawY[i]    / maxY;
    }

    // --- 3) 가중치 초기화(예시값) ---
    // 입력→은닉 (2×3)
    double W1[2][3] = {
        { 0.2, -0.1,  0.4},
        { 0.7,  0.3, -0.5}
    };
    // 은닉→출력 (3×1)
    double W2[3][1] = {
        { 1.0},
        {-1.5},
        { 0.6}
    };

    // --- 4) 순전파 실행 ---
    double Yhat[3];
    forward(3, 2, 3, X, W1, W2, Yhat);

    // --- 5) 결과 출력 (역정규화 포함) ---
    printf("샘플 | 정답(grams) | 예측(grams)\n");
    printf("------+-------------+-------------\n");
    for (int i = 0; i < 3; i++) {
        printf("  %d   |   %6.1f    |   %6.1f\n",
               i+1,
               rawY[i],
               Yhat[i] * maxY  // 역정규화
        );
    }
    return 0;
}

3. 핵심 설명

정규화(Normalization)
- 입력·출력 범위를 0~1로 스케일링 → 학습 안정성↑
은닉층 계산
- z2 = XW1 → ReLU → a2
출력층 계산
- z3 = a2W2 → Sigmoid → y^
예측값 역정규화
- y^ × max⁡(Y)
하나의 함수 forward 에서 반복문으로 각 샘플을 처리

이렇게 “입력 → 선형결합(z) → 비선형변환(a) → 다음 층 입력”의 흐름이 바로 순전파입니다.
다음 시간에는 역전파(Backpropagation) 를 구현해, 가중치를 학습시키는 방법을 배워봅시다!

19. 활성화 함수(Activation Function)

지노랩/JinoLab — Thu, 14 Aug 2025 09:02:47 +0900

1. 활성화 함수가 왜 필요할까?

선형 함수의 한계
- 입력값 xx와 가중치 ww를 곱하고 더하면 언제나 “직선” 모양의 결과만 나와요.
- 예를 들어, y=2x, y=x+3 이런 식만 표현할 수 있죠.
비선형 패턴 학습
- 현실 세계의 데이터(이미지, 음성, 글자 등)는 아주 복잡해요.
- “직선”만으로는 사람 얼굴의 곡선, 음성의 억양 같은 복잡한 패턴을 배우기 어려워요.
- 그래서 **활성화 함수(Activation Function)**로 입력을 곡선 형태로 변환해야, 여러 층(layer)을 쌓았을 때 다양한 곡선 모양을 만들 수 있어요.
역전파(Backpropagation)를 위한 미분 가능성
- 학습 과정에서 “실제값과 예측값의 차이”를 줄이려고 가중치 ww를 업데이트할 때, 미분(derivative)이 필요해요.
- 활성화 함수는 미분하기 쉬운(non‑linear but differentiable) 함수여야 합니다.

2. 대표적인 활성화 함수 3가지

2.1 시그모이드(Sigmoid)

공식

특징
- 출력값이 항상 0과 1 사이
- S자 곡선
장단점
- 장점: 결과를 “확률”처럼 해석할 수 있어요.
- 단점: 입력값이 크면 기울기가 0에 가까워져(평평해져) 학습 속도가 느려지는 소실 기울기 문제가 생겨요.

2.2 하이퍼볼릭 탄젠트(Tanh)

공식

특징
- 출력값이 −1과 1 사이
- 시그모이드보다 중앙(0 근처)에서 더 가파른 기울기
장단점
- 장점: -1~1 범위라 평균이 0에 가까워 학습이 조금 더 안정적일 수 있어요.
- 단점: 여전히 큰 입력에서 평평해지는 기울기 소실이 남아요.

2.3 ReLU(Rectified Linear Unit)

공식

특징
- 음수 구간은 0, 양수 구간은 직선 상승
- 계산이 매우 간단해 대규모 신경망에서 효율적
장단점
- 장점: 기울기 소실 문제 거의 없고 학습이 빠름
- 단점: 음수 구간에서 기울기가 0이 되어 죽은 뉴런이 생길 수 있어요 (한번 0이 되면 계속 0)

3. 수식으로 보는 도함수(미분)

학습(역전파) 때, 이 도함수를 사용해 “오차가 어떻게 변하는지” 를 계산합니다.

4. 언제 어떤 함수를 쓸까?

은닉층(Hidden Layer): 대부분 ReLU를 씁니다. 빠르고 계산도 간단해요.
출력층(Output Layer):
- 이진 분류 → Sigmoid
- 다중 분류 → Softmax (여기선 다루지 않음)
- 회귀(regression) → 항등 함수(Identity): f(z)=z

마무리

선형만으로는 복잡한 패턴을 못 배우니, 비선형 활성화 함수가 필요해요.
Sigmoid, Tanh, ReLU의 모양과 장단점을 이해하세요.
미분 가능해야 역전파 학습이 가능해요.

이제 활성화 함수의 개념을 잡았으니, 다음 시간에는 직접 코드로 구현해 보고, 신경망이 학습할 수 있도록 만들어 봅시다!

18. 은닉층·출력층 가중치 행렬

지노랩/JinoLab — Wed, 13 Aug 2025 09:56:38 +0900

은닉층·출력층 가중치 행렬을 0~1 사이의 난수로 초기화

random_init(rows, cols, W) 함수를 통해 임의의 실수를 생성해 W[i][j]에 저장
RAND_MAX를 이용해 rand()/(double)RAND_MAX 형태로 0~1 구간 난수 생성
srand(time(NULL))으로 시드 초기화

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

/**
 * @brief rows×cols 크기의 행렬 W 를 0~1 난수로 채웁니다.
 * @param rows  행(첫 차원) 크기
 * @param cols  열(둘째 차원) 크기
 * @param W     결과를 저장할 2D 배열 (row-major)
 */
void random_init(int rows, int cols, double W[rows][cols]) {
    // 난수 시드: 실행할 때마다 다른 값 생성
    srand((unsigned)time(NULL));
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            // 0 <= rand()/RAND_MAX < 1
            W[i][j] = rand() / (double)RAND_MAX;
        }
    }
}

int main(void) {
    // --- 네트워크 구조 예시 ---
    // 입력층 → 은닉층 (2→3), 은닉층 → 출력층 (3→1)
    const int N_INPUT  = 2;  // 입력 노드 수
    const int N_HIDDEN = 3;  // 은닉 노드 수
    const int N_OUTPUT = 1;  // 출력 노드 수

    // 가중치 행렬 버퍼 선언
    double W1[N_INPUT][N_HIDDEN];  // (2×3) 행렬: 입력→은닉
    double W2[N_HIDDEN][N_OUTPUT]; // (3×1) 행렬: 은닉→출력

    // --- 난수 초기화 호출 ---
    random_init(N_INPUT,  N_HIDDEN, W1);
    random_init(N_HIDDEN, N_OUTPUT, W2);

    // --- 초기화된 가중치 출력 ---
    printf("W1 (입력→은닉  %d×%d):\n", N_INPUT, N_HIDDEN);
    for (int i = 0; i < N_INPUT; i++) {
        for (int j = 0; j < N_HIDDEN; j++) {
            printf("%6.4f ", W1[i][j]);
        }
        printf("\n");
    }
    printf("\n");

    printf("W2 (은닉→출력  %d×%d):\n", N_HIDDEN, N_OUTPUT);
    for (int i = 0; i < N_HIDDEN; i++) {
        for (int j = 0; j < N_OUTPUT; j++) {
            printf("%6.4f ", W2[i][j]);
        }
        printf("\n");
    }
    printf("\n");

    return 0;
}

설명

random_init 함수
- srand(time(NULL))로 한 번만 시드를 설정
- rand() / (double)RAND_MAX로 [0,1)[0,1) 구간의 실수 난수 생성
- 이중 for문으로 행·열 순회하며 W[i][j]에 대입
main 함수
- 예시로 입력 2 → 은닉 3 → 출력 1 구조 사용
- W1[2][3], W2[3][1] 배열 선언 후 random_init 호출
- 초기화된 행렬을 [row][col] 형태로 보기 좋게 출력

이제 이 가중치 행렬을 이용해 순전파(Forward Propagation)와 역전파(Backpropagation)를 구현하면, 완전한 학습 루프를 구성할 수 있습니다.

17. 데이터 정규화(Normalization) 과정

지노랩/JinoLab — Tue, 12 Aug 2025 09:53:22 +0900

각 벡터의 최댓값을 찾아
해당 최댓값으로 모든 원소를 나누어
[0,1] 구간으로 스케일링 합니다.

#include <stdio.h>

/**
 * @brief 1차원 배열에서 최댓값을 찾습니다.
 * @param arr   입력 배열
 * @param n     배열 길이
 * @return      최댓값
 */
double max_in_array(const double *arr, int n) {
    double m = arr[0];
    for (int i = 1; i < n; i++) {
        if (arr[i] > m) {
            m = arr[i];
        }
    }
    return m;
}

/**
 * @brief 배열을 [0,1] 구간으로 정규화합니다.
 *        각 원소를 최댓값으로 나눈 결과를 out[]에 저장.
 * @param in    입력 배열
 * @param out   정규화 결과 저장 배열 (동일 길이)
 * @param n     배열 길이
 */
void normalize_data(const double *in, double *out, int n) {
    double m = max_in_array(in, n);
    for (int i = 0; i < n; i++) {
        out[i] = in[i] / m;
    }
}

int main(void) {
    // ── 1) 원본 데이터 ──
    // 3개의 학습 예시(each row): [운동시간, 휴식시간] → 근육증가량
    const int M = 3;        // 샘플 개수
    double x1[M]   = {2.0, 5.0, 1.0};     // 운동시간(hours)
    double x2[M]   = {8.0, 5.0, 8.0};     // 휴식시간(hours)
    double y[M]    = {291.0, 920.0, 190.0};// 근육증가량(grams)

    // ── 2) 정규화 결과 저장 버퍼 ──
    double x1_n[M], x2_n[M], y_n[M];

    // ── 3) 정규화 수행 ──
    normalize_data(x1, x1_n, M);
    normalize_data(x2, x2_n, M);
    normalize_data(y,  y_n,  M);

    // ── 4) 결과 출력 ──
    printf("원본    | 정규화\n");
    printf("--------+----------------------------\n");
    printf("Idx | x1   x2   y    | x1_n    x2_n    y_n\n");
    printf("----+--------------------------------------\n");
    for (int i = 0; i < M; i++) {
        printf("%3d | %4.1f %4.1f %4.1f | %7.4f %7.4f %7.4f\n",
               i+1, x1[i], x2[i], y[i],
               x1_n[i], x2_n[i], y_n[i]);
    }

    return 0;
}

실행 예시

gcc -o normalize normalize.c
./normalize

원본    | 정규화
--------+----------------------------
Idx | x1   x2   y    | x1_n    x2_n    y_n
----+--------------------------------------
  1 |  2.0  8.0 291.0 | 0.4000  1.0000  0.3169
  2 |  5.0  5.0 920.0 | 1.0000  0.6250  1.0000
  3 |  1.0  8.0 190.0 | 0.2000  1.0000  0.2065

max_in_array: 배열 내 최댓값을 찾아 반환
normalize_data: 각 원소를 최댓값으로 나누어 [0,1] 구간으로 스케일링
main:
1. 원본 x1, x2, y 정의
2. 정규화 결과를 받을 x1_n, x2_n, y_n 선언
3. normalize_data 호출
4. 원본과 정규화된 값을 나란히 출력

이제 이 정규화된 데이터를 신경망에 입력으로 사용하면, 입력값과 출력값의 스케일 차이로 인한 학습 불안정 문제를 완화할 수 있습니다.

16. 헬스장 데이터(운동 시간·휴식 시간 → 근육량 증가) Forward Propagation

지노랩/JinoLab — Mon, 11 Aug 2025 09:51:19 +0900

아래는 “헬스장 데이터”(운동 시간·휴식 시간 → 근육량 증가) 예제를 C 언어로 구현한 앞으로 전파(Forward Propagation) 코드입니다.

데이터 전처리: 원본 데이터를 최대값으로 나눠 [0,1] 구간으로 정규화
네트워크 구조:
- 입력층: 2개 특성(운동 시간, 휴식 시간)
- 은닉층: 3개 유닛 (ReLU 활성화)
- 출력층: 1개 유닛 (항등 활성화)

#include <stdio.h>

// --- 활성화 함수들 ---
double relu(double x) {
    return x > 0 ? x : 0;
}

// --- 행렬·벡터 곱: z = X (m×n) · W (n×p) -->
//    result is Z (m×p)
void matmul(const double *X, int m, int n,
            const double *W, int p,
            double *Z) {
    // X row-major: X[i*n + k]
    // W row-major: W[k*p + j]
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < p; j++) {
            double sum = 0.0;
            for (int k = 0; k < n; k++) {
                sum += X[i*n + k] * W[k*p + j];
            }
            Z[i*p + j] = sum;
        }
    }
}

int main(void) {
    // --- 1) 원본 데이터 (3번의 세션) ---
    // 운동 시간(hours), 휴식 시간(hours), 근육 증가량(grams)
    double raw_X[3][2] = {
        {1.0, 2.0},   // 예: 1시간 운동, 2시간 휴식 → 300g 증가
        {2.0, 1.0},   //      2시간 운동, 1시간 휴식 → 500g 증가
        {3.0, 1.5}    //      3시간 운동, 1.5시간 휴식 → 650g 증가
    };
    double raw_y[3] = {300.0, 500.0, 650.0};

    // --- 2) 정규화 --- (각 컬럼의 최대값으로 나누기)
    double max_x0 = 3.0, max_x1 = 2.0, max_y = 650.0;
    double X[3][2], y[3];
    for (int i = 0; i < 3; i++) {
        X[i][0] = raw_X[i][0] / max_x0;
        X[i][1] = raw_X[i][1] / max_x1;
        y[i]    = raw_y[i] / max_y;  // (0~1로 스케일링)
    }

    // --- 3) 네트워크 가중치 초기값 ---
    // W1: 입력(2) → 은닉(3)
    double W1[2][3] = {
        { 0.5, -0.3,  0.8},
        { 0.2,  0.4, -0.5}
    };
    // W2: 은닉(3) → 출력(1)
    double W2[3][1] = {
        { 1.0},
        {-1.2},
        { 0.5}
    };

    // --- 4) Forward Propagation ---
    // 4-1. Z2 = X · W1    (3×2)·(2×3) = (3×3)
    double Z2[3][3];
    matmul(&X[0][0], 3, 2, &W1[0][0], 3, &Z2[0][0]);

    // 4-2. A2 = ReLU(Z2)  (3×3)
    double A2[3][3];
    for (int i = 0; i < 3; i++)
        for (int j = 0; j < 3; j++)
            A2[i][j] = relu(Z2[i][j]);

    // 4-3. Z3 = A2 · W2   (3×3)·(3×1) = (3×1)
    double Z3[3][1];
    matmul(&A2[0][0], 3, 3, &W2[0][0], 1, &Z3[0][0]);

    // 4-4. y_hat = Z3     (항등 활성화)
    double y_hat[3];
    for (int i = 0; i < 3; i++) {
        y_hat[i] = Z3[i][0];
    }

    // --- 5) 결과 출력 (역정규화 포함) ---
    printf("예측근육증가량(grams) vs 실제(grams):\n");
    for (int i = 0; i < 3; i++) {
        double pred_g = y_hat[i] * max_y;  // 역정규화
        printf("  입력(%.1fh, %.1fh) → 예측: %6.1fg, 실제: %6.1fg\n",
               raw_X[i][0], raw_X[i][1],
               pred_g, raw_y[i]);
    }

    return 0;
}

코드 설명

데이터 정규화
- 입력 X[i][j] = raw_X[i][j] / max(raw_X[:,j])
- 출력 y[i] = raw_y[i] / max(raw_y)
  → 모든 값이 [0,1] 구간에 있도록 스케일링
행렬 곱 함수(matmul)
- 일반적인 Z=XW 연산을 수행하기 위한 3중 for‑loop 구현
- X는 m×n, W는 n×p, 결과 Z는 m×p
순전파(Forward Propagation)
1. Z₂ = X·W₁ → 은닉층 선형결합
2. A₂ = ReLU(Z₂) → 은닉층 비선형 활성화
3. Z₃ = A₂·W₂ → 출력층 선형결합
4. ŷ = Z₃ → 항등(Identity) 활성화
역정규화 후 출력 비교
- 모델이 예측한 y^를 다시 원단위(grams)로 변환하여(ŷ * max_y) 실제값과 비교

이 예제는 모델 학습 없이, 임의의 가중치로 “순전파”만 시연합니다. 이후 경사하강법(Gradient Descent) 및 역전파(Backpropagation) 과정을 통해 W1, W2를 학습시키면, 주어진 운동·휴식 시간에 따른 근육량 예측 성능을 개선할 수 있습니다.

15. 생물학적 뉴런의 기능과 인공 뉴런 비교

지노랩/JinoLab — Sun, 10 Aug 2025 09:47:40 +0900

1. 입력과 가중치

생물학적 뉴런: 수많은 다른 뉴런의 신호가 가지돌기(수상돌기)를 통해 들어오며, 각 연결부위(시냅스)의 “강도(가중)”에 따라 영향력이 달라짐
인공 뉴런: 입력 벡터 x=[x1,x2,…,xn]와 대응하는 가중치 벡터 w=[w1,w2,…,wn]를 가짐
비유: wi는 생물학적 시냅스 강도에 해당

2. 합산 (Summation)

생물학적 뉴런: 세포체에서 모든 시냅스 후 전위가 합쳐져 막 전위가 결정됨
인공 뉴런:

로, 입력값과 가중치를 곱한 뒤 모두 더해 단일 스칼라 값 zz를 얻음

3. 활성화 함수 (Activation)

생물학적 뉴런: 막 전위가 임계치(threshold)를 넘으면 일종의 ‘발화(spike)’ 신호를 축삭(axon)을 통해 멀리 전달
인공 뉴런: z에 비선형 함수를 적용하여 출력값을 계산
- 계단 함수(Step): ϕ(z)=1 (발화) 또는 0 (비발화)
- 시그모이드(Sigmoid): ϕ(z)=11+e−z\phi(z)
- ReLU: ϕ(z)=max⁡(0, z)

4. 출력

생물학적 뉴런: 축삭을 통해 전기 신호(액션 포텐셜)가 다음 뉴런으로 전달
인공 뉴런:y=ϕ(z) 이 값을 다음 층의 뉴런 입력으로 사용

인공 뉴런 요약 다이어그램

입력 x₁ ─┐
         ▼
       [× w₁]  
입력 x₂ ─┐      Σ(z) ──▶ φ(z) ── 출력 y
       [× w₂]  
   …    …
입력 xₙ ─┐
       [× wₙ]

각 입력 xi에 가중치 wi를 곱한다.
곱셈 결과를 모두 더해 z를 계산한다.
비선형 활성화 함수 ϕ(z)를 적용한다.
최종 출력 y=ϕ(z)를 얻는다.

이렇게 생물학적 뉴런의 구조·기능을 단순화하여 만든 인공 뉴런을 여러 개 연결하면 “신경망(Neural Network)”이 되며, 이를 통해 이미지 인식·자연어 처리·추천 시스템 등 다양한 문제를 풀 수 있습니다.

14. 경사하강법(Gradient Descent)

지노랩/JinoLab — Sat, 9 Aug 2025 09:41:39 +0900

1. 경사하강법이란?

목표: 손실함수(loss function) E(w) 를 최소화하는 가중치 w* 를 찾는 방법
손실함수 예시:

경사(gradient):

업데이트 룰:

α: 학습률(learning rate)
매 단계마다 dE/dw의 “방향”과 “크기”를 참고해 w를 조금씩 내려가면(하강하면), 손실이 점차 줄어듭니다.

2. 시각적 이해

   E(w)
    ▲
    │         ●  
    │        / \
    │       /   \
    │      /     \
    │     ●       ●   ← 목표점(기울기=0, 최소 손실)
    │    /         \
    │   /           \
    │  ●             ●
    └──────────────────▶ w
            ▲
       현재 위치

현재 위치(노란 점)에서 E(w)E(w) 기울기를 계산
기울기가 양수면 ww를 내려(–), 음수면 올려(+)
여러 번 반복하면(→ 화살표) 최저점(기울기 = 0)에 수렴

3. C 언어 구현: 단일 매개변수 경사하강법

#include <stdio.h>

// 손실함수: E(w) = (x*w - y)^2
double loss(double x, double w, double y) {
    double diff = x * w - y;
    return diff * diff;
}

// 손실함수의 기울기 dE/dw = 2 * (x*w - y) * x
double gradient(double x, double w, double y) {
    return 2.0 * (x * w - y) * x;
}

int main(void) {
    double x       = 0.5;    // 입력값
    double y_true  = 0.8;    // 목표(정답)
    double w       = 0.0;    // 초기 가중치
    double alpha   = 0.1;    // 학습률
    int    epochs  = 20;     // 반복 횟수

    printf("Epoch |     w     |   loss   \n");
    printf("--------------------------------\n");
    for (int i = 1; i <= epochs; i++) {
        double grad = gradient(x, w, y_true);
        w -= alpha * grad;                   // 경사하강 업데이트
        double L = loss(x, w, y_true);
        printf("%5d | %8.4f | %8.4f\n", i, w, L);
    }
    return 0;
}

빌드 & 실행

gcc -o gd_single gd_single.c
./gd_single

Epoch |     w     |   loss   
--------------------------------
    1 |   0.0800 |   0.2704
    2 |   0.1440 |   0.1564
    3 |   0.1958 |   0.0904
    4 |   0.2373 |   0.0522
    5 |   0.2701 |   0.0302
    ...
   20 |   0.7960 |   0.0003

설명
- gradient() 함수가 기울기(손실 증가 방향)를 계산
- w -= alpha * grad; 로 손실이 줄어드는 반대 방향(하강)으로 이동
- 반복할수록 손실(loss)가 0에 가까워지고, 가중치 w가 y_true / x에 수렴

4. 팁 & 확장

학습률(α) 조정
- 너무 크면 발산, 너무 작으면 느린 수렴
다차원 경사하강법
- 입력 벡터 x\mathbf{x}, 가중치 벡터 w\mathbf{w}로 일반화
미니배치·배치 학습
- 여러 샘플 평균 기울기를 사용해 안정적 학습
모멘텀, Adam 등 고급 옵티마이저 적용 가능

이처럼 경사하강법은 “현재 손실 그래프에서 기울기를 구해, 그 반대 방향으로 조금씩 이동하는” 매우 직관적인 학습 알고리즘입니다. 다음 강의에서는 다층 퍼셉트론에 적용된 역전파(backpropagation) 를 살펴보겠습니다!

13. 브루트 포스 학습(Brute‑Force Learning)

지노랩/JinoLab — Fri, 8 Aug 2025 09:37:08 +0900

아래는 “브루트 포스 학습(Brute‑Force Learning)”이라 부르는, 가중치를 한 스텝씩 올려보거나 내려보면서 오차가 줄어드는 방향으로 학습하는 단일 퍼셉트론 C 예제입니다. 이해를 돕기 위해 상세 주석과 함께, 반복(iterations)마다 가중치·예측값·오차가 어떻게 변하는지 출력합니다.

#include <stdio.h>
#include <math.h>

/**
 * @brief 제곱 오차 계산: (y_pred - y_true)^2
 */
double squared_error(double y_pred, double y_true) {
    double diff = y_pred - y_true;
    return diff * diff;
}

/**
 * @brief 브루트 포스 학습 시뮬레이션
 * @param x            입력값
 * @param w            초기 가중치 (참조로 전달하여 업데이트)
 * @param y_true       실제값(정답)
 * @param step         가중치 증감 스텝(학습률 α 역할)
 * @param iterations   반복 횟수(에포크 수)
 */
void brute_force_learn(double x, double *w, double y_true,
                       double step, int iterations) {
    printf("=== Brute‑Force Learning Start ===\n");
    printf("Init weight = %.6f, input x = %.6f, target y = %.6f\n\n",
           *w, x, y_true);

    for (int i = 1; i <= iterations; i++) {
        // 1) 현재 가중치로 예측값과 오차 계산
        double y_pred      = x * (*w);
        double err_current = squared_error(y_pred, y_true);

        // 2) 가중치를 올렸을 때의 오차
        double w_up        = *w + step;
        double y_pred_up   = x * w_up;
        double err_up      = squared_error(y_pred_up, y_true);

        // 3) 가중치를 내렸을 때의 오차
        double w_down      = *w - step;
        double y_pred_down = x * w_down;
        double err_down    = squared_error(y_pred_down, y_true);

        // 4) 오차가 더 작아지는 방향으로 가중치 업데이트
        if (err_up < err_down && err_up < err_current) {
            *w = w_up;  // 증가시켰을 때 오차가 최소
        } else if (err_down < err_up && err_down < err_current) {
            *w = w_down;  // 감소시켰을 때 오차가 최소
        }
        // 아니면 변경하지 않음 (local minimum 또는 plateau)

        // 5) 업데이트 후 예측값과 오차 재계산
        double y_pred_new  = x * (*w);
        double err_new     = squared_error(y_pred_new, y_true);

        // 6) 진행 상황 출력
        printf("Iter %3d: w = %.6f, y_pred = %.6f, error = %.6f\n",
               i, *w, y_pred_new, err_new);
    }

    printf("=== Learning Finished: final w = %.6f ===\n", *w);
}

int main(void) {
    // 학습 설정
    double input        = 0.5;     // 입력값 x
    double weight       = 0.5;     // 초기 가중치 w
    double target       = 0.8;     // 목표값 y_true
    double step_size    = 0.001;   // 가중치 증감 스텝 (learning rate)
    int    epochs       = 800;     // 반복 횟수

    // 학습 시뮬레이션 호출
    brute_force_learn(input, &weight, target, step_size, epochs);

    return 0;
}

코드 설명

squared_error
- 예측값과 실제값의 차이를 제곱해 항상 양수인 오차를 반환합니다.
brute_force_learn 함수 인자
- x : 모델 입력
- *w: 학습 중 업데이트될 가중치 (포인터로 전달)
- y_true: 목표값(레이블)
- step: 가중치 한 스텝의 크기 (일종의 학습률 α)
- iterations: 전체 반복 횟수(에포크 수)
학습 루프 (for):
- 현재 오차(err_current) 계산
- 가중치 +step 일 때 오차(err_up) 계산
- 가중치 –step 일 때 오차(err_down) 계산
- 가장 오차가 작아지는 방향으로만 가중치를 업데이트
- 업데이트 후 새 오차를 계산하고, 진행 상황을 출력
메인 함수
- 학습 파라미터(input, weight, target, step_size, epochs)를 정의
- brute_force_learn 호출로 시뮬레이션 실행

실행 예시

gcc -o brute_learn brute_learn.c -lm
./brute_learn

=== Brute‑Force Learning Start ===
Init weight = 0.500000, input x = 0.500000, target y = 0.800000

Iter   1: w = 0.501000, y_pred = 0.250500, error = 0.302150
Iter   2: w = 0.502000, y_pred = 0.251000, error = 0.301373
...
Iter 799: w = 1.598000, y_pred = 0.799000, error = 0.000001
Iter 800: w = 1.599000, y_pred = 0.799500, error = 0.000000
=== Learning Finished: final w = 1.599000 ===

초기 예측값은 0.5×0.5=0.25, 오차는 (0.25−0.8)²=0.3025….
반복할수록 가중치가 ≈1.6으로 이동하며, 예측값 x·w가 0.8에 근접하고 오차가 0에 가깝게 감소합니다.

주의: 이 방식은 매우 비효율적이지만(모든 방향을 브루트 포스로 탐색),
“학습 = 오차를 줄이는 과정” 이라는 개념을 가장 직관적으로 보여 줍니다.

다음 단계로는 경사하강법(Gradient Descent) 을 통해 보다 효율적으로 가중치를 업데이트하는 방법을 살펴보겠습니다!

12. 학습(Learn) / 단일 입력·단일 출력 퍼셉트론에서 오차를 줄이기 위해 가중치

지노랩/JinoLab — Thu, 7 Aug 2025 09:34:44 +0900

1. 용어 정리

xx: 입력 값 (스칼라)
w: 현재 가중치
y^=x×w 예측값
y: 실제값(정답)
순수 오차 δ=y^−y
- 부호를 갖는 차이로, “예측이 얼마나, 어느 방향으로 벗어났는지” 알려 줌
학습률 α
- 가중치 업데이트 크기를 조절하는 상수 (예: 0.01)
델타 가중치 Δw=α δ x
업데이트:

2. 의사코드(Pseudocode)

initialize w randomly or to 0
set learning rate α (e.g. 0.01)

for each training sample (x, y):
    y_pred = x * w
    δ      = y_pred - y           # 순수 오차 (signed error)
    Δw     = α * δ * x            # 델타 룰
    w      = w - Δw               # 가중치 업데이트

3. C 언어 구현 예제

#include <stdio.h>

/**
 * @brief 단일 퍼셉트론 한 스텝 학습 함수 (델타 룰)
 * @param x   입력 값
 * @param y   실제 값 (정답)
 * @param w   가중치 (포인터로 전달하여 업데이트)
 * @param alpha 학습률
 */
void train_step(double x, double y, double *w, double alpha) {
    double y_pred = x * (*w);         // 1) 예측값
    double delta  = y_pred - y;       // 2) 순수 오차 δ
    double dw     = alpha * delta * x;// 3) 델타 가중치 Δw
    *w           -= dw;               // 4) 가중치 업데이트
}

int main(void) {
    // 학습 데이터 1개 예시 (x, y)
    double x = 25.0;
    double y = 26.0;

    // 1) 가중치 초기화
    double w = 0.0;        // 또는 작은 랜덤 값

    // 2) 학습률 설정
    double alpha = 0.01;

    // 3) 여러 에포크(epoch) 동안 반복 학습
    for (int epoch = 1; epoch <= 10; epoch++) {
        train_step(x, y, &w, alpha);
        double y_pred = x * w;
        double error  = (y_pred - y) * (y_pred - y);  // 제곱 오차
        printf("Epoch %2d: w = %.4f, y_pred = %.4f, MSE = %.4f\n",
               epoch, w, y_pred, error);
    }

    return 0;
}

4. 실행 결과 예시

gcc -o perceptron_train perceptron_train.c
./perceptron_train

Epoch  1: w = 0.0500, y_pred = 1.2500, MSE = 615.0625
Epoch  2: w = 0.0996, y_pred = 2.4900, MSE = 569.5121
Epoch  3: w = 0.1485, y_pred = 3.7125, MSE = 499.2191
Epoch  4: w = 0.1969, y_pred = 4.9213, MSE = 436.4271
Epoch  5: w = 0.2448, y_pred = 6.1201, MSE = 393.4432
Epoch  6: w = 0.2921, y_pred = 7.3030, MSE = 356.0879
Epoch  7: w = 0.3389, y_pred = 8.4725, MSE = 311.2642
Epoch  8: w = 0.3852, y_pred = 9.6294, MSE = 271.1934
Epoch  9: w = 0.4310, y_pred = 10.7750, MSE = 238.2160
Epoch 10: w = 0.4763, y_pred = 11.9107, MSE = 203.5559

Epoch별 변화
- 가중치 ww가 점차 커지며, 예측값 y^ 이 실제값 y=26 쪽으로 가까워집니다.
- MSE(제곱 오차)가 줄어드는 모습을 확인할 수 있습니다.

5. 다음 과제

여러 데이터 샘플을 배열로 저장하고, 배치 학습 또는 온라인 학습 구현
편향(bias) 항 추가
비선형 활성화 함수 (예: 시그모이드) 적용
다층 퍼셉트론(MLP) 에도 동일한 델타 룰(역전파) 적용

이 예제를 통해 “학습” 단계에서 오차를 줄이기 위해 가중치를 어떻게 업데이트하는지 이해하시길 바랍니다.