함수와 그래프

학습 목표

이 레슨을 완료하면:

• •함수가 무엇인지 일상 비유로 설명할 수 있습니다
• •1차함수, 2차함수, 지수함수, 로그함수의 모양을 Python으로 직접 그릴 수 있습니다
• •시그모이드와 ReLU가 AI에서 왜 중요한지 이해합니다
• •5가지 핵심 함수를 한 그래프에 비교할 수 있습니다

---

핵심 메시지

"함수를 이해하면 AI의 작동 원리가 보입니다!" 신경망은 결국 함수들의 조합입니다. 각 함수의 특성을 알면, AI가 왜 그렇게 설계되었는지 자연스럽게 이해됩니다.

---

1. 함수란 무엇인가?

자판기 비유

함수를 이해하는 가장 쉬운 방법은 자판기를 떠올리는 것입니다.

• •동전(입력)을 넣으면 → 자판기(규칙)가 처리해서 → 음료(출력)가 나옵니다
• •같은 버튼을 누르면 항상 같은 음료가 나옵니다
• •다른 버튼을 누르면 다른 음료가 나옵니다

수학에서 함수도 똑같습니다:

수학으로 표현하면: y = f(x)

예를 들어 f(x) = 2x + 3이라면:

• •x = 1 넣으면 → 2(1) + 3 = 5
• •x = 4 넣으면 → 2(4) + 3 = 11
• •x = 1을 다시 넣으면 → 여전히 5 (항상 같은 결과!)

실행해보기: 함수를 코드로 표현하기

python
실행복사
import numpy as np

# 함수 정의: f(x) = 2x + 3
def f(x):
    return 2 * x + 3

# 여러 입력값 테스트
inputs = [1, 2, 3, 4, 5]
for x in inputs:
    y = f(x)
    print(f'입력 x={x} → 출력 y={y}')

print()
print('같은 입력은 항상 같은 출력:')
print(f'f(1) = {f(1)}')
print(f'f(1) = {f(1)}  (동일!)')

AI와의 연결: 신경망도 결국 거대한 함수입니다. 이미지(입력)를 넣으면 "고양이"(출력)라고 알려주는 함수인 셈이죠!

---

2. 1차함수: 가장 단순한 직선

비유: 택시 요금

택시를 타면 기본요금 + 거리당 요금이 붙습니다.

• •기본요금: 4,800원 (b = 4800)
• •km당 요금: 1,000원 (a = 1000)
• •총 요금 = 1000 x (거리) + 4800 → 바로 1차함수 y = ax + b!

기울기 a가 크면 → 가파른 직선 (비싼 택시!) 기울기 a가 작으면 → 완만한 직선 (저렴한 택시!)

실행해보기: 1차함수 그래프 그리기

python
실행복사
import numpy as np
import matplotlib.pyplot as plt

x = np.linspace(-5, 5, 100)

# 기울기와 절편이 다른 세 직선
y1 = 2 * x + 1     # 기울기 2, 절편 1
y2 = 0.5 * x - 1   # 기울기 0.5, 절편 -1
y3 = -1 * x + 3    # 기울기 -1, 절편 3

plt.figure(figsize=(8, 5))
plt.plot(x, y1, label='y = 2x + 1 (steep rise)', linewidth=2)
plt.plot(x, y2, label='y = 0.5x - 1 (gentle rise)', linewidth=2)
plt.plot(x, y3, label='y = -x + 3 (descent)', linewidth=2)

plt.axhline(y=0, color='gray', linewidth=0.5)
plt.axvline(x=0, color='gray', linewidth=0.5)
plt.grid(True, alpha=0.3)
plt.xlabel('x')
plt.ylabel('y')
plt.title('1st Function: y = ax + b')
plt.legend()
plt.tight_layout()
plt.show()

AI에서의 역할: 퍼셉트론의 가중합 z = w1x1 + w2x2 + b가 바로 1차함수입니다. 신경망의 가장 기본 연산이에요!

---

3. 2차함수: U자 곡선과 손실 함수

비유: 공 굴리기

U자 모양의 그릇에 공을 놓으면, 공은 자연스럽게 **가장 낮은 곳(바닥)**으로 굴러갑니다. 2차함수 y = x^2 의 그래프가 바로 이 U자 모양입니다.

AI 학습에서 이 "가장 낮은 곳을 찾는 것"이 핵심입니다:

• •U자 곡선 = 손실 함수 (오차를 나타내는 함수)
• •가장 낮은 곳 = 손실이 최소인 지점 (가장 정확한 모델)
• •공이 굴러가는 과정 = 경사하강법 (다음 레슨에서 배웁니다!)

실행해보기: 2차함수와 손실 함수

python
실행복사
import numpy as np
import matplotlib.pyplot as plt

x = np.linspace(-4, 4, 100)

fig, axes = plt.subplots(1, 2, figsize=(12, 5))

# 왼쪽: 기본 2차함수
axes[0].plot(x, x**2, 'b-', linewidth=2, label='y = x^2')
axes[0].plot(x, 0.5*x**2, 'r--', linewidth=2, label='y = 0.5x^2')
axes[0].plot(x, 2*x**2, 'g--', linewidth=2, label='y = 2x^2')
axes[0].plot(0, 0, 'ro', markersize=10)
axes[0].annotate('minimum!', xy=(0, 0), xytext=(1.5, 5),
               arrowprops=dict(arrowstyle='->'), fontsize=12)
axes[0].set_title('Quadratic: y = ax^2')
axes[0].set_xlabel('x')
axes[0].set_ylabel('y')
axes[0].legend()
axes[0].grid(True, alpha=0.3)

# 오른쪽: AI 손실 함수로서의 2차함수
prediction_errors = np.linspace(-3, 3, 100)
loss = prediction_errors ** 2  # MSE

axes[1].plot(prediction_errors, loss, 'r-', linewidth=2)
axes[1].fill_between(prediction_errors, loss, alpha=0.1, color='red')
axes[1].plot(0, 0, 'go', markersize=10)
axes[1].annotate('Goal: reach here!\n(error = 0)', xy=(0, 0), xytext=(1.5, 4),
               arrowprops=dict(arrowstyle='->'), fontsize=11)
axes[1].set_title('Loss Function: (pred - actual)^2')
axes[1].set_xlabel('Prediction Error')
axes[1].set_ylabel('Loss')
axes[1].grid(True, alpha=0.3)

plt.tight_layout()
plt.show()

print('MSE (Mean Squared Error) examples:')
print(f'  error=0 -> loss={0**2}')
print(f'  error=1 -> loss={1**2}')
print(f'  error=3 -> loss={3**2}  (error x3 -> loss x9!)')

핵심 포인트: 오차가 2배가 되면 손실은 4배! 2차함수의 이런 성질 때문에 큰 오차에 더 강하게 반응합니다.

---

4. 지수함수와 로그함수: 폭발과 압축

비유: 소문 퍼지기 vs 지진 규모

지수함수 (y = e^x): 한 사람이 두 사람에게, 두 사람이 네 사람에게 소문을 퍼뜨리면, 순식간에 온 마을이 알게 됩니다. 이것이 "지수적 증가"입니다.

로그함수 (y = log(x)): 지진의 에너지가 10배 커져도 리히터 규모는 1만 올라갑니다. 거대한 수를 작게 압축하는 것이 로그입니다.

실행해보기: 지수함수와 로그함수

python
실행복사
import numpy as np
import matplotlib.pyplot as plt

fig, axes = plt.subplots(1, 2, figsize=(12, 5))

# 왼쪽: 지수함수
x_exp = np.linspace(-2, 3, 100)
axes[0].plot(x_exp, np.exp(x_exp), 'b-', linewidth=2, label='y = e^x')
axes[0].plot(x_exp, 2**x_exp, 'r--', linewidth=2, label='y = 2^x')
axes[0].axhline(y=1, color='gray', linestyle=':', alpha=0.5)
axes[0].set_title('Exponential Function')
axes[0].set_xlabel('x')
axes[0].set_ylabel('y')
axes[0].legend()
axes[0].grid(True, alpha=0.3)
axes[0].set_ylim(-1, 15)

# 오른쪽: 로그함수
x_log = np.linspace(0.01, 10, 100)
axes[1].plot(x_log, np.log(x_log), 'g-', linewidth=2, label='y = ln(x)')
axes[1].plot(x_log, np.log2(x_log), 'm--', linewidth=2, label='y = log2(x)')
axes[1].axhline(y=0, color='gray', linestyle=':', alpha=0.5)
axes[1].axvline(x=1, color='gray', linestyle=':', alpha=0.5)
axes[1].set_title('Logarithm Function')
axes[1].set_xlabel('x')
axes[1].set_ylabel('y')
axes[1].legend()
axes[1].grid(True, alpha=0.3)

plt.tight_layout()
plt.show()

print('exponential: small change -> huge result')
print(f'  e^1 = {np.exp(1):.2f}')
print(f'  e^5 = {np.exp(5):.2f}')
print(f'  e^10 = {np.exp(10):.2f}')
print()
print('log: huge number -> compressed result')
print(f'  ln(1) = {np.log(1):.2f}')
print(f'  ln(100) = {np.log(100):.2f}')
print(f'  ln(10000) = {np.log(10000):.2f}')

AI에서의 핵심: Softmax 함수는 지수함수로 점수를 확률로 바꾸고, 교차 엔트로피 손실은 로그함수로 확률 오차를 계산합니다.

---

5. 시그모이드 함수: 0과 1 사이의 마법

비유: 시험 합격 확률

시험 공부를 아예 안 하면 합격 확률은 거의 0, 엄청 많이 하면 거의 1에 가깝지만, 절대 정확히 0이나 1은 되지 않습니다. 그리고 중간 어딘가에서 급격히 변합니다. 이것이 시그모이드의 S자 곡선입니다!

시그모이드: sigma(x) = 1 / (1 + e^(-x))

실행해보기: 시그모이드 함수 그리기

python
실행복사
import numpy as np
import matplotlib.pyplot as plt

def sigmoid(x):
    return 1 / (1 + np.exp(-x))

x = np.linspace(-8, 8, 200)
y = sigmoid(x)

plt.figure(figsize=(8, 5))
plt.plot(x, y, 'b-', linewidth=2, label='sigmoid(x)')

# 핵심 포인트 표시
plt.axhline(y=0.5, color='gray', linestyle='--', alpha=0.5)
plt.axhline(y=0, color='gray', linestyle=':', alpha=0.3)
plt.axhline(y=1, color='gray', linestyle=':', alpha=0.3)
plt.plot(0, 0.5, 'ro', markersize=8)

# 영역 표시
plt.fill_between(x[x < -2], y[x < -2], alpha=0.1, color='blue')
plt.fill_between(x[x > 2], y[x > 2], alpha=0.1, color='red')
plt.text(-6, 0.15, 'close to 0\n"probably NO"\n', fontsize=10, ha='center')
plt.text(6, 0.85, 'close to 1\n"probably YES"', fontsize=10, ha='center')
plt.text(0.3, 0.42, '(0, 0.5)', fontsize=10)

plt.xlabel('x (input)')
plt.ylabel('sigmoid(x) (output)')
plt.title('Sigmoid Function: any number -> 0~1')
plt.legend()
plt.grid(True, alpha=0.3)
plt.tight_layout()
plt.show()

# 여러 값 테스트
print('sigmoid output examples:')
test_values = [-10, -5, -2, -1, 0, 1, 2, 5, 10]
for v in test_values:
    print(f'  sigmoid({v:3d}) = {sigmoid(v):.6f}')

AI에서의 역할: 스팸 메일 분류에서 시그모이드 출력이 0.85면 "85% 확률로 스팸"이라는 뜻입니다. 이진 분류(Yes/No)의 핵심 함수!

---

6. ReLU 함수: 현대 딥러닝의 일등공신

비유: 마이너스 통장 차단기

ReLU는 아주 단순합니다: "음수면 0, 양수면 그대로 통과!" 마치 은행이 마이너스 잔액을 0으로 처리하는 것과 같습니다.

$\text{ReLU}(x) = \max(0, x)$

왜 ReLU가 시그모이드를 대체했을까?

실행해보기: ReLU와 변형들

python
실행복사
import numpy as np
import matplotlib.pyplot as plt

x = np.linspace(-5, 5, 200)

# ReLU 와 변형들
relu = np.maximum(0, x)
leaky_relu = np.where(x > 0, x, 0.1 * x)  # Leaky ReLU

plt.figure(figsize=(8, 5))
plt.plot(x, relu, 'b-', linewidth=2.5, label='ReLU: max(0, x)')
plt.plot(x, leaky_relu, 'r--', linewidth=2, label='Leaky ReLU: max(0.1x, x)')

plt.axhline(y=0, color='gray', linewidth=0.5)
plt.axvline(x=0, color='gray', linewidth=0.5)
plt.plot(0, 0, 'ko', markersize=8)

plt.xlabel('x (input)')
plt.ylabel('output')
plt.title('ReLU: standard activation of modern deep learning')
plt.legend()
plt.grid(True, alpha=0.3)
plt.tight_layout()
plt.show()

# 직접 계산해보기
print('ReLU calculation:')
test_vals = [-3, -1, 0, 1, 3]
for v in test_vals:
    print(f'  ReLU({v:2d}) = max(0, {v}) = {max(0, v)}')

핵심: ReLU의 단점은 음수 입력에서 뉴런이 "죽을" 수 있다는 것입니다. Leaky ReLU는 음수 구간에서도 작은 기울기(0.1)를 허용하여 이 문제를 해결합니다.

---

7. 종합 비교: 5가지 함수를 한눈에

이제 지금까지 배운 함수들을 한 그래프에 모아서 비교해봅시다.

실행해보기: 5가지 핵심 함수 비교 그래프

python
실행복사
import numpy as np
import matplotlib.pyplot as plt

x = np.linspace(-5, 5, 300)

# 5가지 함수 정의
linear = 0.5 * x + 0.5          # 1차함수
quadratic = 0.1 * x**2          # 2차함수 (스케일 축소)
exponential = np.exp(x) / np.exp(5)  # 지수함수 (스케일 축소)
sigmoid_fn = 1 / (1 + np.exp(-x))    # 시그모이드
relu_fn = np.maximum(0, x)           # ReLU

plt.figure(figsize=(10, 6))
plt.plot(x, linear, '-', linewidth=2, label='Linear: 0.5x+0.5')
plt.plot(x, quadratic, '-', linewidth=2, label='Quadratic: 0.1x^2')
plt.plot(x, sigmoid_fn, '-', linewidth=2, label='Sigmoid')
plt.plot(x, relu_fn, '-', linewidth=2, label='ReLU')
plt.plot(x, exponential, '-', linewidth=2, label='Exp (scaled)')

plt.axhline(y=0, color='gray', linewidth=0.5)
plt.axvline(x=0, color='gray', linewidth=0.5)
plt.ylim(-1, 5)
plt.xlabel('x')
plt.ylabel('y')
plt.title('5 Key Functions for AI - Comparison')
plt.legend(loc='upper left')
plt.grid(True, alpha=0.3)
plt.tight_layout()
plt.show()

---

핵심 요약

---

학습 체크리스트

• • 함수의 정의를 자판기 비유로 설명할 수 있다
• • 1차함수에서 기울기(a)와 절편(b)의 의미를 안다
• • 2차함수가 왜 손실 함수에 적합한지 설명할 수 있다
• • 시그모이드 함수의 출력 범위(0~1)와 AI에서의 용도를 안다
• • ReLU가 시그모이드보다 은닉층에서 선호되는 이유를 설명할 수 있다
• • Python으로 함수 그래프를 그릴 수 있다

---

다음 강의 예고

"미분의 기초" - 변화율과 경사하강법! 함수의 기울기를 구해서 AI가 스스로 학습하는 원리를 배웁니다.