# Part 5.5: NumPy로 배우는 선형대수학

**⬅️ 이전 시간: [Part 5: AI 핵심 라이브러리](../05_ai_core_libraries/part_5_ai_core_libraries.md)**
**➡️ 다음 시간: [Part 6: 머신러닝 모델링과 평가](../06_machine_learning/part_6_machine_learning.md)**

---

<br>

> ## 1. 학습 목표 (Learning Objectives)
>
> 이번 파트가 끝나면, 여러분은 다음을 할 수 있게 됩니다.
> 
> - 머신러닝과 딥러닝의 수학적 기반이 되는 선형대수학의 핵심 개념을 이해할 수 있습니다.
> - NumPy를 사용하여 벡터와 행렬 연산을 수행하고 선형대수학 개념을 코드로 구현할 수 있습니다.
> - 벡터, 행렬, 텐서의 차이점을 설명하고 각각의 연산 방법을 NumPy로 구현할 수 있습니다.
> - 고유값과 고유벡터, 특이값 분해(SVD)의 개념을 이해하고 NumPy로 계산할 수 있습니다.
> - 선형대수학 개념이 머신러닝과 딥러닝에서 어떻게 활용되는지 설명할 수 있습니다.

<br>

> ## 2. 핵심 요약 (Key Summary)
> 
> 이 파트에서는 머신러닝과 딥러닝의 기반이 되는 선형대수학의 핵심 개념들을 NumPy를 활용하여 학습합니다. 벡터와 행렬의 기본 연산부터 시작하여 내적, 외적, 행렬 분해, 고유값과 고유벡터, 특이값 분해(SVD)까지 다양한 선형대수학 개념을 직접 코드로 구현하며 이해합니다. 또한 이러한 개념들이 머신러닝 알고리즘과 딥러닝 모델에서 어떻게 활용되는지 실제 사례를 통해 학습합니다.
> 
> - **핵심 키워드**: `벡터(Vector)`, `행렬(Matrix)`, `텐서(Tensor)`, `내적(Dot Product)`, `외적(Cross Product)`, `행렬식(Determinant)`, `역행렬(Inverse Matrix)`, `고유값(Eigenvalue)`, `고유벡터(Eigenvector)`, `특이값 분해(SVD)`, `선형 변환(Linear Transformation)`

<br>

> ## 3. 도입: 머신러닝의 수학적 기반 (Introduction)
>
> 머신러닝과 딥러닝의 세계로 본격적으로 들어가기 전에, 이 분야의 수학적 기반인 선형대수학을 이해하는 것은 매우 중요합니다. 선형대수학은 벡터와 행렬을 다루는 수학의 한 분야로, 데이터 표현, 변환, 분석의 핵심 도구입니다.
> 
> > [!TIP]
> > 본 파트의 모든 예제 코드는 `../../source_code/part_5.5_linear_algebra_with_numpy.py` 파일에서 직접 실행하고 수정해볼 수 있습니다.
> 
> ### AI 프로젝트에서 선형대수학의 역할
> 
> ```mermaid
> graph TD
>     subgraph "선형대수학의 역할"
>         A["<b>데이터 표현</b><br/>- 벡터, 행렬, 텐서로 데이터 표현<br/>- 고차원 데이터의 효율적 처리"]
>         B["<b>모델 구현</b><br/>- 선형 회귀, PCA 등의 알고리즘<br/>- 신경망의 가중치와 활성화"]
>         C["<b>최적화</b><br/>- 경사 하강법의 수학적 기반<br/>- 역전파 알고리즘"]
>         D["<b>차원 축소</b><br/>- PCA, SVD를 통한 특성 추출<br/>- 데이터 압축과 시각화"]
>     end
> 
>     A -->|"기반 제공"| B
>     B -->|"효율적 계산"| C
>     C -->|"성능 향상"| D
>     D -->|"피드백"| A
> ```
> 
> 이번 파트에서는 NumPy를 활용하여 선형대수학의 핵심 개념들을 직관적으로 이해하고, 이를 코드로 구현하는 방법을 배웁니다. 이론과 실습을 병행하여, 추상적인 수학 개념이 실제 머신러닝과 딥러닝에서 어떻게 활용되는지 명확하게 이해할 수 있을 것입니다.

---

<br>

> ## 4. 벡터와 행렬: 기본 개념과 연산
> 
> > **🎯 1일차 목표:** 벡터와 행렬의 기본 개념을 이해하고 NumPy로 연산하는 방법을 배웁니다.
> 
> ### 4-1. 벡터(Vector): 방향과 크기를 가진 양
> 
> 벡터는 크기와 방향을 가진 양으로, 수학적으로는 숫자의 순서 있는 집합으로 표현됩니다. NumPy에서는 1차원 배열로 표현됩니다.
> 
> ```python
import numpy as np

# 벡터 생성
v1 = np.array([1, 2, 3])
v2 = np.array([4, 5, 6])

# 벡터의 크기(norm) 계산
magnitude_v1 = np.linalg.norm(v1)
print(f"v1의 크기: {magnitude_v1:.2f}")

# 벡터 덧셈과 뺄셈
v_sum = v1 + v2
v_diff = v1 - v2
print(f"벡터 덧셈: {v_sum}")
print(f"벡터 뺄셈: {v_diff}")

# 스칼라 곱
scalar = 2
v_scaled = scalar * v1
print(f"{scalar} * v1 = {v_scaled}")

# 내적(Dot Product)
dot_product = np.dot(v1, v2)
print(f"v1 · v2 = {dot_product}")

# 외적(Cross Product) - 3차원 벡터에만 적용 가능
cross_product = np.cross(v1, v2)
print(f"v1 × v2 = {cross_product}")
```

> [!NOTE] 내적(Dot Product)의 기하학적 의미
> 
> 두 벡터 A와 B의 내적은 `A·B = |A||B|cosθ`로 정의됩니다. 여기서 θ는 두 벡터 사이의 각도입니다.
> 
> - **θ = 0° (같은 방향)**: 내적은 최대값(두 벡터 크기의 곱)
> - **θ = 90° (수직)**: 내적은 0
> - **θ = 180° (반대 방향)**: 내적은 최소값(두 벡터 크기의 곱의 음수)
> 
> 이러한 특성 때문에 내적은 두 벡터의 유사도를 측정하는 데 자주 사용됩니다. 머신러닝에서 코사인 유사도(cosine similarity)가 바로 이 원리를 활용합니다.
> 
> ### 4-2. 행렬(Matrix): 2차원 데이터 구조
> 
> 행렬은 숫자를 직사각형 형태로 배열한 것으로, 행(row)과 열(column)로 구성됩니다. NumPy에서는 2차원 배열로 표현됩니다.
> 
> ```python
# 행렬 생성
A = np.array([[1, 2], [3, 4]])
B = np.array([[5, 6], [7, 8]])

print(f"행렬 A:\n{A}")
print(f"행렬 B:\n{B}")

# 행렬 덧셈과 뺄셈
C = A + B
D = A - B
print(f"A + B =\n{C}")
print(f"A - B =\n{D}")

# 행렬 곱셈
E = np.matmul(A, B)  # 또는 A @ B (Python 3.5 이상)
print(f"A × B =\n{E}")

# 전치 행렬(Transpose)
A_T = A.T
print(f"A의 전치 행렬:\n{A_T}")

# 행렬식(Determinant)
det_A = np.linalg.det(A)
print(f"A의 행렬식: {det_A}")

# 역행렬(Inverse Matrix)
inv_A = np.linalg.inv(A)
print(f"A의 역행렬:\n{inv_A}")

# 역행렬 검증: A × A^(-1) = I (단위 행렬)
I = np.matmul(A, inv_A)
print(f"A × A^(-1) =\n{np.round(I, decimals=10)}")  # 부동소수점 오차 처리
```

> [!NOTE] 행렬 곱셈의 의미
> 
> 행렬 곱셈은 선형 변환의 합성을 나타냅니다. 예를 들어, 행렬 A가 회전 변환을 나타내고 행렬 B가 크기 조절 변환을 나타낸다면, A×B는 "먼저 크기를 조절한 후 회전"하는 복합 변환을 나타냅니다.
> 
> 머신러닝에서 행렬 곱셈은 특히 중요합니다. 예를 들어, 신경망의 한 층에서 입력 벡터 x와 가중치 행렬 W의 곱 W×x는 각 뉴런의 가중 합(weighted sum)을 계산합니다.

---

<br>

> ## 5. 고급 선형대수학 개념과 NumPy 구현
> 
> > **🎯 2일차 목표:** 고유값, 고유벡터, SVD 등 고급 선형대수학 개념을 이해하고 NumPy로 구현합니다.
> 
> ### 5-1. 고유값(Eigenvalue)과 고유벡터(Eigenvector)
> 
> 고유벡터는 선형 변환(행렬 곱셈)을 거쳐도 방향이 변하지 않는 특별한 벡터입니다. 고유값은 그 과정에서 벡터의 크기가 변하는 비율을 나타냅니다.
> 
> 수학적으로, 정방행렬 A에 대해 Av = λv를 만족하는 벡터 v와 스칼라 λ가 있다면, v는 A의 고유벡터이고 λ는 대응하는 고유값입니다.
> 
> ```python
# 예제 행렬
A = np.array([[4, -2], [1, 1]])

# 고유값과 고유벡터 계산
eigenvalues, eigenvectors = np.linalg.eig(A)

print(f"고유값: {eigenvalues}")
print(f"고유벡터:\n{eigenvectors}")

# 검증: A × v = λ × v
for i in range(len(eigenvalues)):
    v = eigenvectors[:, i]
    Av = np.matmul(A, v)
    lambda_v = eigenvalues[i] * v
    print(f"\n고유값 {eigenvalues[i]}에 대한 검증:")
    print(f"A × v = {Av}")
    print(f"λ × v = {lambda_v}")
```

> [!NOTE] 고유값과 고유벡터의 응용
> 
> 고유값과 고유벡터는 데이터 과학과 머신러닝에서 매우 중요한 역할을 합니다:
> 
> - **주성분 분석(PCA)**: 데이터의 공분산 행렬의 고유벡터는 데이터의 주요 변동 방향을 나타냅니다. 이를 통해 차원 축소와 특성 추출이 가능합니다.
> - **PageRank 알고리즘**: Google의 초기 검색 알고리즘은 웹 그래프의 인접 행렬의 주요 고유벡터를 사용하여 웹페이지의 중요도를 계산했습니다.
> - **안정성 분석**: 동적 시스템의 안정성은 시스템 행렬의 고유값을 통해 분석할 수 있습니다.
> 
> ### 5-2. 특이값 분해(Singular Value Decomposition, SVD)
> 
> SVD는 어떤 행렬이든 세 개의 특별한 행렬의 곱으로 분해하는 방법입니다: A = UΣV^T. 여기서 U와 V는 직교 행렬이고, Σ는 대각 행렬입니다.
> 
> SVD는 행렬이 정방행렬이 아니거나 역행렬이 존재하지 않는 경우에도 적용할 수 있어, 더 일반적인 행렬 분해 방법입니다.
> 
> ```python
# 예제 행렬 (비정방행렬)
B = np.array([[3, 2, 2], [2, 3, -2]])

# SVD 계산
U, Sigma, VT = np.linalg.svd(B)

print(f"U 행렬:\n{U}")
print(f"특이값: {Sigma}")
print(f"V^T 행렬:\n{VT}")

# 원래 행렬 복원
# Sigma는 대각 요소만 반환하므로, 대각 행렬로 변환해야 함
Sigma_matrix = np.zeros(B.shape)
for i in range(min(B.shape)):
    Sigma_matrix[i, i] = Sigma[i]

B_reconstructed = U @ Sigma_matrix @ VT
print(f"\n복원된 행렬:\n{B_reconstructed}")
```

> [!NOTE] SVD의 응용
> 
> SVD는 머신러닝과 데이터 과학에서 다양하게 활용됩니다:
> 
> - **차원 축소**: PCA와 유사하게, SVD를 사용하여 데이터의 중요한 특성만 추출할 수 있습니다.
> - **이미지 압축**: 큰 이미지 행렬에서 가장 중요한 특이값만 사용하여 이미지를 압축할 수 있습니다.
> - **추천 시스템**: Netflix와 같은 추천 시스템에서 사용자-아이템 행렬의 SVD를 통해 잠재 요인(latent factors)을 추출하여 추천에 활용합니다.
> - **노이즈 제거**: 신호 처리에서 작은 특이값에 해당하는 성분을 제거하여 노이즈를 줄일 수 있습니다.
> 
> ### 5-3. 주성분 분석(PCA)과 고유값 분해
> 
> PCA는 고차원 데이터의 분산을 최대한 보존하면서 저차원으로 축소하는 기법입니다. 이는 데이터 공분산 행렬의 고유값 분해를 통해 구현됩니다.
> 
> > [!NOTE] PCA와 고유값 분해의 관계
> > 
> > 데이터의 공분산 행렬은 데이터가 각 차원에서 얼마나 흩어져 있는지, 그리고 차원 간에 어떤 상관관계가 있는지를 나타냅니다.
> > - **고유벡터**: 공분산 행렬의 고유벡터는 데이터가 가장 크게 분산된 방향(주성분)을 가리킵니다. 즉, 데이터의 '주요 축'을 나타냅니다.
> > - **고유값**: 각 고유벡터에 해당하는 고유값은 해당 방향으로 데이터가 얼마나 많이 분산되어 있는지를 나타냅니다. 고유값이 클수록 더 중요한 주성분입니다.
> > 
> > 따라서, 가장 큰 고유값들을 가진 고유벡터(주성분)들로 원래 데이터를 투영(projection)하면, 원본 데이터의 분산을 최대한 유지하면서 차원을 축소할 수 있습니다.
> 
> ```python
# PCA 예제
# 데이터 생성
np.random.seed(42)
mean = [0, 0]
cov = [[5, 4], [4, 5]]  # 공분산 행렬
data = np.random.multivariate_normal(mean, cov, 200)

# 데이터 중앙 정렬
X = data - data.mean(axis=0)

# 공분산 행렬 계산
cov_matrix = np.cov(X.T)
print(f"공분산 행렬:\n{cov_matrix}")

# 고유값과 고유벡터 계산
eigenvalues, eigenvectors = np.linalg.eig(cov_matrix)

# 고유값을 기준으로 내림차순 정렬
sorted_indices = np.argsort(eigenvalues)[::-1]
sorted_eigenvalues = eigenvalues[sorted_indices]
sorted_eigenvectors = eigenvectors[:, sorted_indices]

print(f"고유값: {sorted_eigenvalues}")
print(f"고유벡터:\n{sorted_eigenvectors}")

# 주성분 (PC)
pc1 = sorted_eigenvectors[:, 0]
pc2 = sorted_eigenvectors[:, 1]

print(f"\n첫 번째 주성분 (PC1): {pc1}")
print(f"두 번째 주성분 (PC2): {pc2}")

# 데이터를 주성분으로 투영 (차원 축소)
transformed_data = X @ sorted_eigenvectors

# 시각화
import matplotlib.pyplot as plt

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

# 원본 데이터
plt.subplot(1, 2, 1)
plt.scatter(X[:, 0], X[:, 1], alpha=0.7)
# 주성분 벡터 그리기
origin = [0, 0]
plt.quiver(*origin, *pc1*np.sqrt(sorted_eigenvalues[0]), color='r', scale=5, label=f'PC1 (Variance: {sorted_eigenvalues[0]:.2f})')
plt.quiver(*origin, *pc2*np.sqrt(sorted_eigenvalues[1]), color='g', scale=5, label=f'PC2 (Variance: {sorted_eigenvalues[1]:.2f})')
plt.title('Original Data with Principal Components')
plt.xlabel('Feature 1')
plt.ylabel('Feature 2')
plt.axis('equal')
plt.legend()

# 변환된 데이터
plt.subplot(1, 2, 2)
plt.scatter(transformed_data[:, 0], transformed_data[:, 1], alpha=0.7)
plt.title('Data Transformed by PCA')
plt.xlabel('Principal Component 1')
plt.ylabel('Principal Component 2')
plt.axis('equal')

plt.tight_layout()
plt.show()
```

---

<br>

> ## 6. 텐서(Tensor): 다차원 데이터의 표현
> 
> > **🎯 3일차 목표:** 텐서의 개념을 이해하고 NumPy로 다차원 데이터를 다루는 방법을 학습합니다.
> 
> ### 6-1. 텐서란 무엇인가?
> 
> 텐서는 벡터와 행렬을 일반화한 다차원 배열입니다. 딥러닝에서 텐서는 데이터를 표현하는 기본 단위로 사용됩니다.
> 
> - **0차원 텐서 (스칼라)**: 숫자 하나 (e.g., `5`)
> - **1차원 텐서 (벡터)**: 숫자의 배열 (e.g., `[1, 2, 3]`)
> - **2차원 텐서 (행렬)**: 숫자의 2차원 배열 (e.g., `[[1, 2], [3, 4]]`)
> - **3차원 텐서**: 숫자의 3차원 배열 (e.g., 컬러 이미지 (높이, 너비, 채널))
> - **4차원 텐서**: 숫자의 4차원 배열 (e.g., 이미지 데이터의 미니배치 (배치 크기, 높이, 너비, 채널))
> 
> ### 6-2. NumPy로 텐서 다루기
> 
> ```python
> # 3차원 텐서 생성 (2x3x4)
> T = np.arange(24).reshape(2, 3, 4)
> 
> print(f"3차원 텐서 T:\n{T}")
> print(f"\n텐서의 모양(shape): {T.shape}")
> print(f"텐서의 차원 수(ndim): {T.ndim}")
> print(f"텐서의 총 요소 수(size): {T.size}")
> 
> # 텐서 인덱싱
> print(f"\nT[1, 0, 2] = {T[1, 0, 2]}")
> 
> # 텐서 슬라이싱
> print(f"\nT[:, 0, :] =\n{T[:, 0, :]}") # 각 행렬의 첫 번째 행
> ```
> 
> ### 6-3. 텐서 연산
> 
> 텐서 연산은 기본적으로 요소별(element-wise)로 수행됩니다.
> 
> ```python
> T1 = np.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])
> T2 = np.array([[[9, 10], [11, 12]], [[13, 14], [15, 16]]])
> 
> # 텐서 덧셈
> T_sum = T1 + T2
> print(f"텐서 덧셈:\n{T_sum}")
> 
> # 텐서 곱셈 (요소별)
> T_prod = T1 * T2
> print(f"\n텐서 곱셈 (요소별):\n{T_prod}")
> 
> # 텐서 내적 (Tensor Dot Product)
> # np.tensordot은 축을 지정하여 내적을 수행
> # 예: (2, 2, 2) 텐서와 (2, 2, 2) 텐서의 마지막 두 축에 대해 내적
> T_dot = np.tensordot(T1, T2, axes=([1, 2], [1, 2]))
> print(f"\n텐서 내적 (axes=([1,2],[1,2])):\n{T_dot}")
> ```
> 
> > [!NOTE] 딥러닝에서의 텐서 연산
> > 딥러닝 프레임워크(TensorFlow, PyTorch)에서는 복잡한 텐서 연산을 효율적으로 처리하기 위한 다양한 함수를 제공합니다. 특히 GPU를 활용한 병렬 처리를 통해 대규모 텐서 연산을 가속화합니다.

---

<br>

> ## 7. 마무리 및 다음 파트 예고
> 
> 이번 파트에서는 NumPy를 사용하여 선형대수학의 핵심 개념들을 살펴보았습니다. 벡터, 행렬, 텐서의 기본 연산부터 시작하여 고유값, 고유벡터, SVD와 같은 고급 주제까지 다루었습니다. 이러한 개념들은 머신러닝과 딥러닝 모델을 이해하고 구현하는 데 필수적인 수학적 도구입니다.
> 
> 다음 파트에서는 드디어 본격적인 **머신러닝의 세계**로 들어갑니다. 선형 회귀, 로지스틱 회귀와 같은 기본적인 머신러닝 모델을 직접 구현하고 평가하며, 모델 학습의 전체 과정을 경험하게 될 것입니다. 이번 파트에서 배운 선형대수학 지식이 다음 파트의 모델들을 이해하는 데 어떻게 사용되는지 직접 확인할 수 있을 것입니다.
> 
> > [!TIP]
> > **다음으로 무엇을 해야 할까요?**
> > - `source_code/part_5.5_linear_algebra_with_numpy.py` 파일의 코드를 직접 실행하고, 값을 바꿔보며 결과가 어떻게 변하는지 확인해보세요.
> > - 특히 SVD를 이용한 이미지 압축이나 PCA를 이용한 차원 축소 예제를 직접 다른 데이터에 적용해보세요.
> > - 궁금한 점이 있다면 언제든지 질문해주세요!

<br>

---

**⬅️ 이전 시간: [Part 5: AI 핵심 라이브러리](../05_ai_core_libraries/part_5_ai_core_libraries.md)**
**➡️ 다음 시간: [Part 6: 머신러닝 모델링과 평가](../06_machine_learning/part_6_machine_learning.md)** 