Split View: 선형대수학 완전정복: 벡터부터 SVD까지 제로투히어로 가이드

import numpy as np

# 벡터 정의
a = np.array([1, 2, 3])
b = np.array([4, 5, 6])

# 벡터 덧셈
print("덧셈:", a + b)          # [5 7 9]

# 스칼라 곱
print("스칼라 곱:", 3 * a)     # [3 6 9]

# 내적
dot = np.dot(a, b)
print("내적:", dot)             # 32

# 외적
cross = np.cross(a, b)
print("외적:", cross)           # [-3  6 -3]

# L2 노름
norm_l2 = np.linalg.norm(a)
print("L2 노름:", norm_l2)      # 3.7416...

# L1 노름
norm_l1 = np.linalg.norm(a, ord=1)
print("L1 노름:", norm_l1)      # 6.0

# 단위벡터
unit = a / np.linalg.norm(a)
print("단위벡터:", unit)
print("크기 확인:", np.linalg.norm(unit))  # 1.0

# 두 벡터의 각도
cos_theta = np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))
angle = np.arccos(cos_theta)
print("각도 (라디안):", angle)
print("각도 (도):", np.degrees(angle))

import numpy as np

# 행렬 정의
A = np.array([[1, 2], [3, 4]])
B = np.array([[5, 6], [7, 8]])

# 행렬 덧셈
print("행렬 덧셈:\n", A + B)

# 행렬 곱
C = A @ B
print("행렬 곱:\n", C)

# 원소별 곱 (Hadamard product)
print("원소별 곱:\n", A * B)

# 전치행렬
print("전치행렬:\n", A.T)

# 역행렬
A_inv = np.linalg.inv(A)
print("역행렬:\n", A_inv)

# 검증: A @ A_inv = I
print("검증 (A @ A_inv):\n", A @ A_inv)

# 단위행렬
I = np.eye(3)
print("3x3 단위행렬:\n", I)

# 대각행렬
D = np.diag([1, 2, 3])
print("대각행렬:\n", D)

# 대칭행렬 생성
S = A @ A.T
print("대칭행렬 (A @ A^T):\n", S)
print("대칭 확인:", np.allclose(S, S.T))

import numpy as np

A = np.array([[1, 2, 3],
              [4, 5, 6],
              [7, 8, 9]])

B = np.array([[2, -1, 0],
              [-1, 2, -1],
              [0, -1, 2]])

# 행렬식 계산
det_A = np.linalg.det(A)
det_B = np.linalg.det(B)
print("det(A):", det_A)   # 거의 0 (특이행렬에 가까움)
print("det(B):", det_B)   # 4.0

# 성질 검증: det(A@B) = det(A)*det(B)
print("det(A)*det(B):", det_A * det_B)
print("det(A@B):", np.linalg.det(A @ B))

# 크라머 공식으로 연립방정식 풀기
A_sys = np.array([[2, 1], [5, 3]], dtype=float)
b_sys = np.array([1, 2], dtype=float)

det_A_sys = np.linalg.det(A_sys)

# x1 계산
A1 = A_sys.copy()
A1[:, 0] = b_sys
x1 = np.linalg.det(A1) / det_A_sys

# x2 계산
A2 = A_sys.copy()
A2[:, 1] = b_sys
x2 = np.linalg.det(A2) / det_A_sys

print(f"x1 = {x1}, x2 = {x2}")
# numpy linalg solve로 검증
x = np.linalg.solve(A_sys, b_sys)
print("numpy solve:", x)

import numpy as np
from scipy import linalg

# 연립방정식: 2x + y = 5, x + 3y = 10
A = np.array([[2, 1], [1, 3]], dtype=float)
b = np.array([5, 10], dtype=float)

# numpy linalg.solve
x = np.linalg.solve(A, b)
print("해:", x)  # [1. 3.]

# 가우스-조르단 소거법 구현
def gauss_jordan(A, b):
    n = len(b)
    # 첨가행렬 생성
    aug = np.hstack([A.astype(float), b.reshape(-1, 1).astype(float)])

    for col in range(n):
        # 피벗 선택 (부분 피벗팅)
        max_row = np.argmax(np.abs(aug[col:, col])) + col
        aug[[col, max_row]] = aug[[max_row, col]]

        # 피벗 행 정규화
        aug[col] = aug[col] / aug[col, col]

        # 다른 행에서 소거
        for row in range(n):
            if row != col:
                aug[row] -= aug[row, col] * aug[col]

    return aug[:, -1]

solution = gauss_jordan(A.copy(), b.copy())
print("가우스-조르단 해:", solution)

# LU 분해
P, L, U = linalg.lu(A)
print("L 행렬:\n", L)
print("U 행렬:\n", U)
print("P 행렬:\n", P)

# LU 분해로 연립방정식 풀기
x_lu = linalg.solve(A, b)
print("LU 분해 해:", x_lu)

import numpy as np

A = np.array([[1, 2, 3],
              [4, 5, 6],
              [2, 4, 6]])  # 3행은 1행의 2배 (선형종속)

# 랭크 계산
rank = np.linalg.matrix_rank(A)
print("랭크:", rank)  # 2

# 영공간 (null space) 계산
from scipy.linalg import null_space
ns = null_space(A)
print("영공간:\n", ns)

# 열공간의 기저 (QR 분해 활용)
Q, R = np.linalg.qr(A)
print("열공간의 기저 (Q의 처음 rank개 열):\n", Q[:, :rank])

# 선형독립 확인 예시
v1 = np.array([1, 0, 0])
v2 = np.array([0, 1, 0])
v3 = np.array([0, 0, 1])
M = np.column_stack([v1, v2, v3])
print("v1, v2, v3의 랭크:", np.linalg.matrix_rank(M))  # 3 = 선형독립

v4 = np.array([1, 2, 3])
v5 = np.array([2, 4, 6])  # v5 = 2*v4
M2 = np.column_stack([v4, v5])
print("v4, v5의 랭크:", np.linalg.matrix_rank(M2))  # 1 = 선형종속

import numpy as np
import matplotlib.pyplot as plt

# 회전 변환
def rotation_matrix(theta):
    return np.array([[np.cos(theta), -np.sin(theta)],
                     [np.sin(theta),  np.cos(theta)]])

# 45도 회전
theta = np.pi / 4
R = rotation_matrix(theta)
print("45도 회전 행렬:\n", R)

# 벡터 변환
v = np.array([1, 0])
v_rotated = R @ v
print("회전된 벡터:", v_rotated)  # [0.707, 0.707]

# 전단 변환 (shear)
shear = np.array([[1, 1],
                  [0, 1]])

# 단위 정사각형의 꼭짓점 변환
corners = np.array([[0, 1, 1, 0, 0],
                    [0, 0, 1, 1, 0]])

transformed = shear @ corners
print("전단 변환 후 꼭짓점:\n", transformed)

# 직교 행렬 검증
print("R^T @ R =\n", R.T @ R)  # 단위행렬
print("det(R) =", np.linalg.det(R))  # 1

import numpy as np

def gram_schmidt(vectors):
    """그람-슈미트 정규직교화"""
    basis = []
    for v in vectors:
        w = v.copy().astype(float)
        for b in basis:
            w -= np.dot(v, b) * b
        norm = np.linalg.norm(w)
        if norm > 1e-10:
            basis.append(w / norm)
    return np.array(basis)

# 선형독립인 벡터들
v1 = np.array([1, 1, 0])
v2 = np.array([1, 0, 1])
v3 = np.array([0, 1, 1])

# 그람-슈미트 적용
basis = gram_schmidt([v1, v2, v3])
print("정규직교기저:\n", basis)

# 직교성 확인
print("내적 확인 (0이어야 함):")
print("e1 dot e2:", np.dot(basis[0], basis[1]))
print("e1 dot e3:", np.dot(basis[0], basis[2]))
print("e2 dot e3:", np.dot(basis[1], basis[2]))

# 단위벡터 확인
print("노름 확인 (1이어야 함):")
for i, b in enumerate(basis):
    print(f"  e{i+1} 노름:", np.linalg.norm(b))

# scipy의 그람-슈미트 (QR 분해 활용)
A = np.column_stack([v1, v2, v3])
Q, R = np.linalg.qr(A)
print("QR 분해 Q 행렬:\n", Q)

import numpy as np
from scipy.linalg import eig

# 일반 행렬의 고유값/고유벡터
A = np.array([[4, 1],
              [2, 3]])

eigenvalues, eigenvectors = np.linalg.eig(A)
print("고유값:", eigenvalues)          # [5., 2.]
print("고유벡터 (열):\n", eigenvectors)

# 검증: A @ v = lambda * v
for i in range(len(eigenvalues)):
    lam = eigenvalues[i]
    v = eigenvectors[:, i]
    print(f"\nlambda={lam:.2f}:")
    print("  A @ v:", A @ v)
    print("  lambda * v:", lam * v)

# 고유값 분해: A = P @ Lambda @ P^{-1}
P = eigenvectors
Lambda = np.diag(eigenvalues)
A_reconstructed = P @ Lambda @ np.linalg.inv(P)
print("\n재구성 행렬:\n", A_reconstructed)
print("원래 행렬과 동일:", np.allclose(A, A_reconstructed))

# 대칭 행렬 (실수 고유값 보장)
B = np.array([[2, 1, 0],
              [1, 3, 1],
              [0, 1, 2]])

eigenvalues_B, eigenvectors_B = np.linalg.eigh(B)  # 대칭 행렬 전용
print("\n대칭 행렬 고유값:", eigenvalues_B)
print("직교성 확인 (Q^T @ Q = I):\n",
      np.round(eigenvectors_B.T @ eigenvectors_B))

# 거듭제곱: A^n = P @ Lambda^n @ P^{-1}
n = 5
Lambda_n = np.diag(eigenvalues ** n)
A_power = P @ Lambda_n @ np.linalg.inv(P)
print(f"\nA^{n}:\n", A_power)
print("직접 계산과 비교:\n", np.linalg.matrix_power(A, n))

import numpy as np
import matplotlib.pyplot as plt

# 기본 SVD
A = np.array([[1, 2, 3],
              [4, 5, 6],
              [7, 8, 9],
              [10, 11, 12]])

U, S, Vt = np.linalg.svd(A)
print("U 형태:", U.shape)      # (4, 4)
print("S (특이값):", S)         # 특이값
print("Vt 형태:", Vt.shape)    # (3, 3)

# 재구성 검증
Sigma = np.zeros(A.shape)
Sigma[:min(A.shape), :min(A.shape)] = np.diag(S)
A_reconstructed = U @ Sigma @ Vt
print("재구성 오차:", np.linalg.norm(A - A_reconstructed))

# 이미지 압축 시뮬레이션
def svd_compress(matrix, k):
    """상위 k개 특이값으로 행렬 압축"""
    U, S, Vt = np.linalg.svd(matrix)
    # k개 성분만 사용
    U_k = U[:, :k]
    S_k = S[:k]
    Vt_k = Vt[:k, :]
    return U_k @ np.diag(S_k) @ Vt_k

# 테스트 행렬 (이미지 시뮬레이션)
np.random.seed(42)
img = np.random.randn(100, 100)

# 다양한 압축 비율 테스트
for k in [5, 10, 20, 50]:
    compressed = svd_compress(img, k)
    error = np.linalg.norm(img - compressed, 'fro') / np.linalg.norm(img, 'fro')
    compression_ratio = k * (100 + 100 + 1) / (100 * 100)
    print(f"k={k}: 상대 오차={error:.4f}, 압축비={compression_ratio:.4f}")

# PCA 구현 (SVD 활용)
def pca_svd(X, n_components):
    """SVD를 이용한 PCA"""
    # 데이터 중심화
    X_centered = X - X.mean(axis=0)

    # SVD 수행
    U, S, Vt = np.linalg.svd(X_centered, full_matrices=False)

    # 주성분으로 투영
    X_pca = X_centered @ Vt[:n_components].T

    # 설명 분산 비율
    explained_variance_ratio = (S[:n_components]**2) / (S**2).sum()

    return X_pca, Vt[:n_components], explained_variance_ratio

# 예시 데이터
np.random.seed(42)
X = np.random.randn(100, 5)
X_pca, components, evr = pca_svd(X, 2)
print("\nPCA 설명 분산 비율:", evr)
print("투영된 데이터 형태:", X_pca.shape)

import numpy as np
from scipy import linalg

# QR 분해
A = np.array([[1, 2, 3],
              [4, 5, 6],
              [7, 8, 10]], dtype=float)

Q, R = np.linalg.qr(A)
print("Q (직교 행렬):\n", Q)
print("R (상삼각 행렬):\n", R)
print("Q^T @ Q = I 확인:\n", np.round(Q.T @ Q))

# Cholesky 분해
B = np.array([[4, 2, 2],
              [2, 3, 1],
              [2, 1, 3]], dtype=float)

L = np.linalg.cholesky(B)
print("\nCholesky L:\n", L)
print("L @ L^T = A 확인:\n", L @ L.T)

# LU 분해 (scipy)
P, L_lu, U = linalg.lu(A)
print("\nLU 분해:")
print("P:\n", P)
print("L:\n", L_lu)
print("U:\n", U)
print("P @ L @ U = A 확인:\n", np.round(P @ L_lu @ U))

import numpy as np
from sklearn.decomposition import PCA
from sklearn.datasets import load_iris

# 1. 간단한 신경망 순전파
np.random.seed(42)
n_samples, input_dim, hidden_dim, output_dim = 32, 784, 128, 10

X = np.random.randn(n_samples, input_dim)
W1 = np.random.randn(input_dim, hidden_dim) * 0.01
b1 = np.zeros(hidden_dim)
W2 = np.random.randn(hidden_dim, output_dim) * 0.01
b2 = np.zeros(output_dim)

# 순전파
H1 = np.maximum(0, X @ W1 + b1)  # ReLU 활성화
logits = H1 @ W2 + b2
print("logits 형태:", logits.shape)  # (32, 10)

# 2. PCA로 차원 축소
iris = load_iris()
X_iris = iris.data  # (150, 4)

pca = PCA(n_components=2)
X_pca = pca.fit_transform(X_iris)
print("\nPCA 후 형태:", X_pca.shape)  # (150, 2)
print("설명 분산 비율:", pca.explained_variance_ratio_)
print("누적 설명 분산:", pca.explained_variance_ratio_.sum())

# 3. Scaled Dot-Product Attention
def scaled_dot_product_attention(Q, K, V):
    d_k = Q.shape[-1]
    # Q @ K^T / sqrt(d_k)
    scores = Q @ K.T / np.sqrt(d_k)

    # Softmax
    exp_scores = np.exp(scores - scores.max(axis=-1, keepdims=True))
    attention_weights = exp_scores / exp_scores.sum(axis=-1, keepdims=True)

    # 가중 합
    output = attention_weights @ V
    return output, attention_weights

# 예시
seq_len, d_model = 5, 8
Q = np.random.randn(seq_len, d_model)
K = np.random.randn(seq_len, d_model)
V = np.random.randn(seq_len, d_model)

output, weights = scaled_dot_product_attention(Q, K, V)
print("\nAttention 출력 형태:", output.shape)  # (5, 8)
print("Attention 가중치 합:", weights.sum(axis=-1))  # 모두 1

# 4. Word Embedding 유사도
word_embeddings = {
    "king": np.array([0.8, 0.3, 0.1, 0.9]),
    "queen": np.array([0.7, 0.4, 0.2, 0.8]),
    "man": np.array([0.6, 0.1, 0.7, 0.2]),
    "woman": np.array([0.5, 0.2, 0.8, 0.1])
}

def cosine_similarity(a, b):
    return np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))

print("\n단어 유사도:")
print("king-queen:", cosine_similarity(
    word_embeddings["king"], word_embeddings["queen"]))
print("man-woman:", cosine_similarity(
    word_embeddings["man"], word_embeddings["woman"]))

# king - man + woman ≈ queen (analogy)
analogy = word_embeddings["king"] - word_embeddings["man"] + word_embeddings["woman"]
sim_queen = cosine_similarity(analogy, word_embeddings["queen"])
print("king - man + woman vs queen 유사도:", sim_queen)

벡터 → 행렬 → 행렬식 → 연립방정식
  ↓       ↓
벡터 공간 → 선형 변환 → 내적 공간
  ↓
고유값/고유벡터 → SVD → AI/ML 응용