행렬 곱셈: AI의 핵심 연산

(m × n) · (n × p) = (m × p)

⚠️ 첫 행렬의 열 수 = 두 번째 행렬의 행 수 일치 필수

예: A는 2×3, B는 3×4
   A·B = (2×3) · (3×4) = 2×4

원소 계산:
(A·B)[i][j] = Σ A[i][k] · B[k][j]
            = A의 i행과 B의 j열의 내적

A = [[1, 2],     B = [[5, 6, 7],
     [3, 4]]          [8, 9, 10]]

A·B =
  [[1*5+2*8, 1*6+2*9, 1*7+2*10],
   [3*5+4*8, 3*6+4*9, 3*7+4*10]]
  = [[21, 24, 27],
     [47, 54, 61]]

import numpy as np

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

# @ 연산자 (Python 3.5+)
print(A @ B)
# [[21 24 27]
#  [47 54 61]]


# 또는 np.matmul / np.dot
print(np.matmul(A, B))
print(np.dot(A, B))  # 1D는 내적, 2D는 행렬 곱


# ⚠️ * 는 원소별 곱 (행렬 곱 아님)
# A * B → ValueError (형태 다름)


# 단위 행렬과 곱 — 자기 자신
I = np.eye(2)
print(A @ I)
# [[1 2]
#  [3 4]]


# 행렬 곱은 비가환 — A·B ≠ B·A
C = np.array([[1, 2], [3, 4]])
D = np.array([[5, 6], [7, 8]])
print(C @ D)
print(D @ C)
# 결과가 다름

import numpy as np

# 간단한 신경망: 입력 3 → 은닉 4 → 출력 2

# 입력 (1 샘플)
x = np.array([0.5, 0.3, 0.8])  # shape (3,)

# 가중치 (학습되는 파라미터)
W1 = np.random.randn(3, 4)  # 입력 → 은닉
b1 = np.zeros(4)
W2 = np.random.randn(4, 2)  # 은닉 → 출력
b2 = np.zeros(2)


def relu(x):
    return np.maximum(0, x)


def forward(x):
    # 1층: 입력 → 은닉
    z1 = x @ W1 + b1   # 행렬 곱 + 편향
    a1 = relu(z1)      # 활성화

    # 2층: 은닉 → 출력
    z2 = a1 @ W2 + b2
    return z2


output = forward(x)
print(output)


# 배치 처리 — 여러 샘플 한 번에
X_batch = np.random.randn(100, 3)  # 100 샘플, 각 3차원

# 행렬 곱이 그대로 동작
def forward_batch(X):
    Z1 = X @ W1 + b1   # (100, 3) @ (3, 4) = (100, 4)
    A1 = relu(Z1)
    Z2 = A1 @ W2 + b2  # (100, 4) @ (4, 2) = (100, 2)
    return Z2


outputs = forward_batch(X_batch)
print(outputs.shape)  # (100, 2)

# 행렬 곱셈 = 수백만 개 독립적인 곱셈·덧셈
# CPU: 순차 처리 (수십 코어)
# GPU: 병렬 처리 (수천 코어)


import numpy as np
import time

# 1000x1000 행렬 곱셈
size = 1000
A = np.random.randn(size, size)
B = np.random.randn(size, size)

# CPU (numpy)
t0 = time.perf_counter()
C = A @ B
print(f"CPU numpy: {(time.perf_counter() - t0)*1000:.0f}ms")
# 약 50~200ms (CPU 종류에 따라)


# GPU (PyTorch CUDA — 설치 필요)
"""
import torch
A_gpu = torch.tensor(A).cuda()
B_gpu = torch.tensor(B).cuda()
t0 = time.perf_counter()
C_gpu = A_gpu @ B_gpu
torch.cuda.synchronize()  # GPU 작업 완료 대기
print(f"GPU CUDA: {(time.perf_counter() - t0)*1000:.0f}ms")
# 약 1~5ms (10~100배 빠름)
"""

표준 행렬 곱: O(n³)
  m×n 행렬과 n×p 행렬 → O(m×n×p)
  정사각 n×n → O(n³)

스트라센 알고리즘: O(n^2.807)
  분할 정복 + 7번 곱셈 (8 대신)
  큰 행렬에서 효과

실제 라이브러리: BLAS·LAPACK·cuBLAS
  최적화된 메모리 접근 패턴 + SIMD + 캐시
  numpy·PyTorch는 내부적으로 사용

// CSS transform은 2D/3D 행렬 곱셈
// matrix3d(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p)

const div = document.getElementById('box');

// 회전 + 크기 + 이동을 한 번에 — 행렬 곱셈으로 합성
const angle = Math.PI / 4;  // 45도
const scale = 1.5;
const tx = 100, ty = 50;

div.style.transform = `
  matrix(
    ${Math.cos(angle) * scale}, ${Math.sin(angle) * scale},
    ${-Math.sin(angle) * scale}, ${Math.cos(angle) * scale},
    ${tx}, ${ty}
  )
`;