linear_numpy.py - Examples

  1"""
  2Linear Regression - NumPy From-Scratch 구현
  3
  4이 파일은 선형 회귀를 순수 NumPy로 구현합니다.
  5프레임워크 없이 gradient descent를 직접 구현하여
  6딥러닝의 기본 원리를 이해합니다.
  7
  8학습 목표:
  91. Forward pass: y_hat = Xw + b
 102. Loss 계산: MSE = (1/2n) * ||y - y_hat||^2
 113. Backward pass: gradient 계산
 124. Weight update: w = w - lr * dw
 13"""
 14
 15import numpy as np
 16import matplotlib.pyplot as plt
 17
 18
 19class LinearRegressionNumpy:
 20    """
 21    NumPy로 구현한 Linear Regression
 22
 23    수학적 배경:
 24    - 모델: ŷ = Xw + b
 25    - 손실: L = (1/2n) Σ(y - ŷ)²
 26    - 그래디언트:
 27        ∂L/∂w = (1/n) X^T (ŷ - y)
 28        ∂L/∂b = (1/n) Σ(ŷ - y)
 29    """
 30
 31    def __init__(self, input_dim: int, output_dim: int = 1):
 32        """
 33        Args:
 34            input_dim: 입력 특성 수
 35            output_dim: 출력 차원 (기본 1)
 36        """
 37        # Xavier/He 초기화: 분산을 2/n으로 유지
 38        self.W = np.random.randn(input_dim, output_dim) * np.sqrt(2.0 / input_dim)
 39        self.b = np.zeros((1, output_dim))
 40
 41        # 그래디언트 저장용
 42        self.dW = None
 43        self.db = None
 44
 45        # Forward에서 캐시 (backward에서 사용)
 46        self._cache = {}
 47
 48    def forward(self, X: np.ndarray) -> np.ndarray:
 49        """
 50        Forward pass: ŷ = Xw + b
 51
 52        Args:
 53            X: 입력 데이터 (batch_size, input_dim)
 54
 55        Returns:
 56            y_hat: 예측값 (batch_size, output_dim)
 57        """
 58        # 입력 캐시 (backward에서 필요)
 59        self._cache['X'] = X
 60
 61        # 선형 변환: y = Xw + b
 62        y_hat = np.dot(X, self.W) + self.b
 63
 64        return y_hat
 65
 66    def compute_loss(self, y: np.ndarray, y_hat: np.ndarray) -> float:
 67        """
 68        Mean Squared Error 손실 계산
 69
 70        L = (1/2n) Σ(y - ŷ)²
 71
 72        Args:
 73            y: 실제값 (batch_size, output_dim)
 74            y_hat: 예측값 (batch_size, output_dim)
 75
 76        Returns:
 77            loss: 스칼라 손실값
 78        """
 79        n = y.shape[0]
 80        loss = (1 / (2 * n)) * np.sum((y - y_hat) ** 2)
 81        return loss
 82
 83    def backward(self, y: np.ndarray, y_hat: np.ndarray) -> None:
 84        """
 85        Backward pass: 그래디언트 계산
 86
 87        Chain Rule 적용:
 88        ∂L/∂w = ∂L/∂ŷ × ∂ŷ/∂w
 89               = (1/n)(ŷ - y) × X^T
 90               = (1/n) X^T (ŷ - y)
 91
 92        ∂L/∂b = ∂L/∂ŷ × ∂ŷ/∂b
 93               = (1/n) Σ(ŷ - y)
 94
 95        Args:
 96            y: 실제값
 97            y_hat: 예측값
 98        """
 99        X = self._cache['X']
100        n = y.shape[0]
101
102        # 오차
103        error = y_hat - y  # (batch_size, output_dim)
104
105        # 그래디언트 계산
106        # ∂L/∂W = (1/n) X^T @ error
107        self.dW = (1 / n) * np.dot(X.T, error)
108
109        # ∂L/∂b = (1/n) Σerror (각 출력 차원별)
110        self.db = (1 / n) * np.sum(error, axis=0, keepdims=True)
111
112    def update(self, lr: float) -> None:
113        """
114        가중치 업데이트 (Gradient Descent)
115
116        w = w - η × ∂L/∂w
117        b = b - η × ∂L/∂b
118
119        Args:
120            lr: learning rate
121        """
122        self.W -= lr * self.dW
123        self.b -= lr * self.db
124
125    def fit(
126        self,
127        X: np.ndarray,
128        y: np.ndarray,
129        lr: float = 0.01,
130        epochs: int = 1000,
131        verbose: bool = True
132    ) -> list:
133        """
134        모델 학습
135
136        Args:
137            X: 학습 데이터 (n_samples, n_features)
138            y: 타겟값 (n_samples, 1) 또는 (n_samples,)
139            lr: learning rate
140            epochs: 학습 반복 횟수
141            verbose: 진행 상황 출력 여부
142
143        Returns:
144            losses: 에폭별 손실 리스트
145        """
146        # y shape 보정
147        if y.ndim == 1:
148            y = y.reshape(-1, 1)
149
150        losses = []
151
152        for epoch in range(epochs):
153            # 1. Forward pass
154            y_hat = self.forward(X)
155
156            # 2. Loss 계산
157            loss = self.compute_loss(y, y_hat)
158            losses.append(loss)
159
160            # 3. Backward pass (gradient 계산)
161            self.backward(y, y_hat)
162
163            # 4. Weight update
164            self.update(lr)
165
166            # 진행 상황 출력
167            if verbose and (epoch + 1) % (epochs // 10) == 0:
168                print(f"Epoch {epoch + 1}/{epochs}, Loss: {loss:.6f}")
169
170        return losses
171
172    def predict(self, X: np.ndarray) -> np.ndarray:
173        """예측"""
174        return self.forward(X)
175
176
177def generate_sample_data(n_samples: int = 100, n_features: int = 1, noise: float = 0.1):
178    """
179    테스트용 샘플 데이터 생성
180
181    y = 2x + 3 + noise
182    """
183    np.random.seed(42)
184    X = np.random.randn(n_samples, n_features)
185
186    # 실제 가중치 (학습으로 찾아야 할 값)
187    true_w = np.array([[2.0]])
188    true_b = 3.0
189
190    y = np.dot(X, true_w) + true_b + noise * np.random.randn(n_samples, 1)
191
192    return X, y, true_w, true_b
193
194
195def main():
196    """메인 실행 함수"""
197    print("=" * 60)
198    print("Linear Regression - NumPy From-Scratch 구현")
199    print("=" * 60)
200
201    # 1. 데이터 생성
202    print("\n1. 샘플 데이터 생성")
203    X, y, true_w, true_b = generate_sample_data(n_samples=100, noise=0.1)
204    print(f"   X shape: {X.shape}")
205    print(f"   y shape: {y.shape}")
206    print(f"   True w: {true_w.flatten()}, True b: {true_b}")
207
208    # 2. 모델 생성
209    print("\n2. 모델 초기화")
210    model = LinearRegressionNumpy(input_dim=1, output_dim=1)
211    print(f"   Initial W: {model.W.flatten()}")
212    print(f"   Initial b: {model.b.flatten()}")
213
214    # 3. 학습
215    print("\n3. 학습 시작")
216    losses = model.fit(X, y, lr=0.1, epochs=100, verbose=True)
217
218    # 4. 결과 확인
219    print("\n4. 학습 결과")
220    print(f"   Learned W: {model.W.flatten()}")
221    print(f"   Learned b: {model.b.flatten()}")
222    print(f"   True W: {true_w.flatten()}")
223    print(f"   True b: {true_b}")
224    print(f"   Final Loss: {losses[-1]:.6f}")
225
226    # 5. 시각화
227    print("\n5. 시각화")
228    fig, axes = plt.subplots(1, 2, figsize=(12, 4))
229
230    # Loss 곡선
231    axes[0].plot(losses)
232    axes[0].set_xlabel('Epoch')
233    axes[0].set_ylabel('Loss (MSE)')
234    axes[0].set_title('Training Loss')
235    axes[0].grid(True)
236
237    # 데이터와 예측 직선
238    y_pred = model.predict(X)
239    sorted_idx = np.argsort(X.flatten())
240    axes[1].scatter(X, y, alpha=0.5, label='Data')
241    axes[1].plot(X[sorted_idx], y_pred[sorted_idx], 'r-', linewidth=2, label='Prediction')
242    axes[1].set_xlabel('X')
243    axes[1].set_ylabel('y')
244    axes[1].set_title('Linear Regression Fit')
245    axes[1].legend()
246    axes[1].grid(True)
247
248    plt.tight_layout()
249    plt.savefig('linear_regression_result.png', dpi=150)
250    plt.show()
251    print("   결과 이미지 저장: linear_regression_result.png")
252
253
254if __name__ == "__main__":
255    main()