Perceptron

# Rosenblatt의 퍼셉트론 알고리즘 구현
import numpy as np

# AND 게이트 데이터
X_original = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])
# 각 입력에 1을 추가하여 [x1, x2, 1] 형태로 만듦
# 이렇게 하면 편향(bias)도 가중치의 일부가 됨
X = np.column_stack([X_original, np.ones(len(X_original))])  # [x1, x2, 1]
y = np.array([0, 0, 0, 1])

print("Rosenblatt의 AND 게이트 퍼셉트론 학습 알고리즘")
print("=" * 60)
print(f"입력 데이터 (augmented):\n{X}")
print(f"목표 출력: {y}\n")

# 계단 함수 (Step Function) - Rosenblatt의 활성화 함수
def step_function(x):
    """입력이 0보다 크거나 같으면 1, 아니면 0을 반환"""
    return 1 if x >= 0 else 0

def forward(X, w):
    """
    순전파: 가중합 계산
    """
    z = np.dot(X, w)
    return step_function(z)

# 가중치 초기화 (bias 포함: [w1, w2, b])
# Rosenblatt는 보통 작은 랜덤 값이나 0으로 초기화
np.random.seed(1)
w = np.random.randn(3) * 0.1  # [w1, w2, bias]

print(f"초기 가중치: w = [{w[0]:.4f}, {w[1]:.4f}, {w[2]:.4f}]")
print(f"초기 가중치 해석: w1={w[0]:.4f}, w2={w[1]:.4f}, bias={w[2]:.4f}\n")

# 학습률 설정
lr = 0.1

# 학습 반복 횟수
n_epochs = 10

# 추적을 위한 리스트
epoch_errors = []  # 각 epoch의 오류 개수
epoch_accuracy = []  # 각 epoch의 정확도

print("학습 시작...")
print("-" * 60)

for epoch in range(n_epochs):
    errors = 0
    
    for i in range(len(X)):
        x = X[i]  # [x1, x2, 1]
        y_true = y[i]

        # 활성화 함수 적용 (계단 함수)
        y_pred = forward(x, w)
        
        # Rosenblatt 학습 규칙: 오류가 있을 때만 가중치 업데이트
        # 가중치 업데이트: w = w + α * (y_true - y_pred) * x
        if y_pred != y_true:
            error = y_true - y_pred # +1 또는 -1
            # error 가 1인 경우, w * x 는 증가해야 함
            # error 가 -1인 경우, w * x 는 감소해야 함
            w += lr * error * x 
            errors += 1
    
    # 기록
    accuracy = (len(X) - errors) / len(X)
    epoch_errors.append(errors)
    epoch_accuracy.append(accuracy)
    
    # 학습 진행 상황 출력
    if errors == 0:
        print(f"Epoch {epoch+1}: 수렴 완료! (모든 샘플 정확히 분류) - 정확도 = {accuracy:.2%}")
        break
    print(f"Epoch {epoch+1}: 정확도 = {accuracy:.2%}")

print("-" * 60)
print(f"\n최종 가중치: w = [{w[0]:.4f}, {w[1]:.4f}, {w[2]:.4f}]")
print(f"해석: w1={w[0]:.4f}, w2={w[1]:.4f}, bias={w[2]:.4f}\n")

all_correct = True
for i in range(len(X)):
    x = X[i]
    z = np.dot(w, x)
    y_pred = forward(x, w)
    y_true = y[i]
    status = "✓ 정확" if y_pred == y_true else "✗ 오류"
    if y_pred != y_true:
        all_correct = False
    print(f"{str(X_original[i]):<15} {z:>10.4f}  {y_pred:>6}    {y_true:>6}    {status}")

import matplotlib.pyplot as plt

# Decision Boundary 그래프 - 별도 figure
plt.figure(figsize=(6, 6))
plt.scatter(X_original[y == 0, 0], X_original[y == 0, 1], 
           c='red', s=150, marker='o', label='Output = 0', 
           edgecolors='black', linewidths=2, alpha=0.7)
plt.scatter(X_original[y == 1, 0], X_original[y == 1, 1], 
           c='blue', s=150, marker='s', label='Output = 1', 
           edgecolors='black', linewidths=2, alpha=0.7)

# Draw decision boundary: w1*x1 + w2*x2 + bias = 0
# x2 = -(w1*x1 + bias) / w2
if abs(w[1]) > 1e-10:  # When w2 is not zero
    x1_line = np.linspace(-0.5, 1.5, 100)
    x2_line = -(w[0] * x1_line + w[2]) / w[1]
    plt.plot(x1_line, x2_line, 'g-', linewidth=3, alpha=0.8)

# x, y 축 그리기 (0, 0이 왼쪽 아래 구석에 오도록)
plt.axhline(y=0, color='black', linewidth=1, linestyle='-', alpha=0.5)
plt.axvline(x=0, color='black', linewidth=1, linestyle='-', alpha=0.5)

plt.xlim(-0.1, 1.5)
plt.ylim(-0.1, 1.5)
plt.xlabel('x1')
plt.ylabel('x2')
plt.title('AND Gate Decision Boundary')
plt.grid(True, alpha=0.3, linestyle='--')
plt.legend(fontsize=12, loc='upper right')
plt.show()

# Accuracy 그래프 - 별도 figure

plt.figure(figsize=(7, 5))
# Epoch 범위 생성
epochs_range = range(1, len(epoch_errors) + 1)

plt.plot(epochs_range, epoch_accuracy, 'g-^', linewidth=2, markersize=8, label='Accuracy')
plt.xlabel('Epoch')
plt.ylabel('Accuracy')
plt.title('AND Gate Accuracy per Epoch')
plt.grid(True, alpha=0.3, linestyle='--')
plt.legend(fontsize=10)
plt.axhline(y=1.0, color='gray', linestyle='--', alpha=0.5, label='Perfect Accuracy')
plt.tight_layout()
plt.show()