활성화 함수(Activation Function)

마일스톤 학습법으로 단계별 완전 정복

딥러닝

활성화함수

ReLU

Sigmoid

Tanh

비선형성

기울기소실

Swish

GELU

이 개념 직접 실험하기 — 활성화 함수 시뮬레이터

이 학습을 통해 달성할 수 있는 목표

기초 이해

• 활성화 함수의 역할과 필요성 이해
• 주요 활성화 함수들의 특성과 사용법 파악
• 문제 유형에 따른 기본적인 함수 선택 능력

심화 학습

• 활성화 함수의 수학적 특성과 미분 이해
• 기울기 소실, 죽은 뉴런 등의 문제점 파악
• 네트워크 설계 시 활성화 함수 최적 선택 능력

실무 적용

• 최신 활성화 함수들의 특징과 발전 과정 이해
• 활성화 함수 자동 탐색과 설계 방법론 파악
• 연구 트렌드와 미래 방향성 이해

한눈에 보기

활성화 함수는 뉴런의 가중합에 적용하는 비선형 함수로, 신경망이 단순한 선형 결합을 넘어 복잡한 비선형 관계를 학습하게 해준다.

활성화 함수가 없으면 층을 아무리 쌓아도 전체가 하나의 선형변환이라 표현력이 늘지 않는다.
ReLU(max(0, x))는 계산이 싸고 그래디언트 소실을 완화해 은닉층의 사실상 표준이 됐다.
출력층은 목적에 맞춰 고른다 — 이진분류는 시그모이드, 다중분류는 소프트맥스, 회귀는 항등함수.

이 내용은 넘스탯의 활성화 함수 시뮬레이터에서 직접 실험으로 확인할 수 있습니다.

학습 로드맵

각 단계를 클릭하면 해당 학습 내용을 볼 수 있습니다

기초 이해

개념 정의와 기본 원리

약 20분

클릭

심화 학습

공식 유도와 다양한 예시

약 35분

클릭

실무 적용

실제 케이스와 고급 응용

약 50분

학습 진도 (완료한 단계)

먼저 알아두면 좋은 개념들

인공신경망 기초

뉴런의 동작 원리와 신경망 구조 이해가 선행되어야 함

기초 단계뉴런의 의사결정자, 활성화 함수

기초 단계: 뉴런의 의사결정자, 활성화 함수

난이도 2/5

약 20분

활성화 함수는 뉴런이 받은 입력을 처리하여 최종 출력을 결정하는 함수입니다. 마치 사람이 여러 정보를 종합해서 "예/아니오"를 결정하듯이, 활성화 함수는 계산된 값을 적절한 범위로 변환합니다.

활성화 함수를 "온도계의 표시 방식"으로 생각해보세요. 같은 온도라도 섭씨로 표시하면 0~100, 화씨로 표시하면 32~212가 됩니다. 활성화 함수는 뉴런의 계산 결과를 특정 범위와 특성에 맞게 변환하는 역할을 합니다. 시그모이드는 0~1 범위로, tanh는 -1~1 범위로, ReLU는 0 이상으로 출력을 제한합니다.

핵심 포인트

•비선형성: 복잡한 패턴 학습을 위해 비선형 변환 수행
•범위 제한: 출력값을 특정 범위로 조정하여 안정적인 학습
•미분 가능: 역전파 학습을 위해 미분 가능한 함수 사용
•종류별 특성: 문제에 따라 적합한 활성화 함수 선택 필요

간단한 예시

간단한 분류 문제 예시: • 입력: 학생의 공부시간(5시간), 출석률(90%) • 가중합: 5×0.3 + 90×0.7 = 64.5 • 시그모이드 적용: σ(64.5) ≈ 1.0 • 결과 해석: "시험 합격 확률 100%" 아래 Python 코드로 활성화 함수를 직접 만들어볼 수 있습니다.

Python으로 직접 실행해보기

아래 코드는 브라우저에서 바로 실행됩니다. 숫자를 바꿔가며 결과를 눈으로 확인해 보세요.

1단계: 기본 활성화 함수 구현

가장 많이 사용되는 활성화 함수들을 직접 만들어보세요

Colab에서 열기

import numpy as np
import matplotlib.pyplot as plt

# 1. 시그모이드 함수 (0~1 범위 출력)
def sigmoid(x):
    return 1 / (1 + np.exp(-np.clip(x, -500, 500)))

# 2. ReLU 함수 (0 이상만 통과)
def relu(x):
    return np.maximum(0, x)

# 3. tanh 함수 (-1~1 범위 출력)
def tanh(x):
    return np.tanh(x)

# 4. Leaky ReLU (음수도 작은 기울기로 통과)
def leaky_relu(x, alpha=0.01):
    return np.where(x > 0, x, alpha * x)

# 각 함수의 특성 시각화
x = np.linspace(-5, 5, 100)

plt.figure(figsize=(12, 8))

# 시그모이드
plt.subplot(2, 2, 1)
plt.plot(x, sigmoid(x), 'r-', linewidth=2, label='Sigmoid')
plt.title('Sigmoid: 부드러운 S자 곡선')
plt.xlabel('입력값')
plt.ylabel('출력값')
plt.grid(True, alpha=0.3)
plt.legend()
plt.text(-4, 0.8, '특징: 0~1 범위\n용도: 이진 분류',
         bbox=dict(boxstyle="round", facecolor='wheat', alpha=0.8))

# ReLU
plt.subplot(2, 2, 2)
plt.plot(x, relu(x), 'b-', linewidth=2, label='ReLU')
plt.title('ReLU: 간단하고 빠른 함수')
plt.xlabel('입력값')
plt.ylabel('출력값')
plt.grid(True, alpha=0.3)
plt.legend()
plt.text(-4, 3, '특징: 음수는 0\n용도: 은닉층',
         bbox=dict(boxstyle="round", facecolor='lightblue', alpha=0.8))

# Tanh
plt.subplot(2, 2, 3)
plt.plot(x, tanh(x), 'g-', linewidth=2, label='Tanh')
plt.title('Tanh: 균형잡힌 함수')
plt.xlabel('입력값')
plt.ylabel('출력값')
plt.grid(True, alpha=0.3)
plt.legend()
plt.text(-4, 0.5, '특징: -1~1 범위\n용도: RNN, LSTM',
         bbox=dict(boxstyle="round", facecolor='lightgreen', alpha=0.8))

# Leaky ReLU
plt.subplot(2, 2, 4)
plt.plot(x, leaky_relu(x), 'm-', linewidth=2, label='Leaky ReLU')
plt.title('Leaky ReLU: ReLU 개선버전')
plt.xlabel('입력값')
plt.ylabel('출력값')
plt.grid(True, alpha=0.3)
plt.legend()
plt.text(-4, 2, '특징: 음수도 작게 통과\n용도: Dead ReLU 해결',
         bbox=dict(boxstyle="round", facecolor='plum', alpha=0.8))

plt.tight_layout()
plt.show()

print("활성화 함수 학습 포인트:")
print("• Sigmoid: 확률값이 필요한 출력층에 적합")
print("• ReLU: 계산이 빠르고 기울기 소실 문제 해결")
print("• Tanh: 0 중심이라 학습이 더 안정적")
print("• Leaky ReLU: ReLU의 죽은 뉴런 문제 해결")

첫 실행 시 파이썬 런타임을 내려받습니다 (수 초 소요)

코드 설명: 각 활성화 함수의 모양과 특성을 직접 확인해보세요. 입력 범위에 따라 어떻게 출력이 변하는지 관찰할 수 있습니다!

2단계: 활성화 함수 선택 실험

같은 문제를 다른 활성화 함수로 해결해보며 차이점을 알아보세요

Colab에서 열기

# 간단한 뉴런 네트워크로 함수별 성능 비교
import numpy as np
import matplotlib.pyplot as plt

class SimpleNeuron:
    def __init__(self, activation_func):
        self.activation_func = activation_func
        self.weights = np.random.randn(2) * 0.5
        self.bias = 0
        self.losses = []

def predict(self, X):
        z = np.dot(X, self.weights) + self.bias
        return self.activation_func(z)

def train(self, X, y, epochs=1000, lr=0.1):
        for epoch in range(epochs):
            # 순전파
            z = np.dot(X, self.weights) + self.bias
            a = self.activation_func(z)

# 손실 계산 (평균제곱오차)
            loss = np.mean((a - y) ** 2)
            self.losses.append(loss)

# 역전파 (간단한 경사하강법)
            if self.activation_func.__name__ == 'sigmoid':
                dz = (a - y) * a * (1 - a)  # 시그모이드 미분
            elif self.activation_func.__name__ == 'tanh':
                dz = (a - y) * (1 - a**2)   # tanh 미분
            else:  # ReLU
                dz = (a - y) * (z > 0)      # ReLU 미분

dw = np.dot(X.T, dz) / len(X)
            db = np.mean(dz)

# 가중치 업데이트
            self.weights -= lr * dw
            self.bias -= lr * db

# 예제 데이터: AND 논리 게이트
X = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])
y = np.array([0, 0, 0, 1])  # AND 연산 결과

# 각 활성화 함수로 뉴런 생성
neurons = {
    'Sigmoid': SimpleNeuron(sigmoid),
    'Tanh': SimpleNeuron(tanh),
    'ReLU': SimpleNeuron(relu)
}

# 학습 진행
print("AND 논리 게이트 학습 시작")
for name, neuron in neurons.items():
    print(f"학습 중: {name} 활성화 함수")
    neuron.train(X, y, epochs=500, lr=0.5)

# 결과 비교
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(15, 5))

# 1. 학습 곡선 비교
for name, neuron in neurons.items():
    ax1.plot(neuron.losses, label=name, linewidth=2)
ax1.set_xlabel('Epoch')
ax1.set_ylabel('Loss')
ax1.set_title('활성화 함수별 학습 속도 비교')
ax1.legend()
ax1.grid(True, alpha=0.3)

# 2. 최종 예측 결과
names = list(neurons.keys())
final_losses = [neurons[name].losses[-1] for name in names]
colors = ['red', 'green', 'blue']
bars = ax2.bar(names, final_losses, color=colors, alpha=0.7)
ax2.set_ylabel('최종 Loss')
ax2.set_title('활성화 함수별 최종 성능')

# 막대 위에 수치 표시
for i, bar in enumerate(bars):
    height = bar.get_height()
    ax2.text(bar.get_x() + bar.get_width()/2., height + 0.001,
             f'{height:.4f}', ha='center', va='bottom')

plt.tight_layout()
plt.show()

# 각 뉴런의 AND 게이트 예측 결과
print("\n=== AND 논리 게이트 학습 결과 ===")
for name, neuron in neurons.items():
    predictions = neuron.predict(X)
    print(f"\n{name} 활성화 함수:")
    for i in range(4):
        print(f"  {X[i]} → 예측: {predictions[i]:.3f}, 정답: {y[i]}")

# 정확도 계산 (0.5 기준으로 분류)
    binary_pred = (predictions > 0.5).astype(int)
    accuracy = np.mean(binary_pred == y) * 100
    print(f"  정확도: {accuracy:.1f}%")

첫 실행 시 파이썬 런타임을 내려받습니다 (수 초 소요)

코드 설명: 동일한 AND 논리 게이트 문제를 서로 다른 활성화 함수로 해결해보세요. 어떤 함수가 더 빠르고 정확하게 학습하는지 비교할 수 있습니다!

딥러닝 이론 페이지로 돌아가기