프로그래밍과 AI를 위한 수학 기초 — 개발자 수학 로드맵

# 수학: Σᵢ₌₁ⁿ i # 코드로 읽으면 그냥 for loop def sigma(n): total = 0 for i in range(1, n + 1): total += i return total # 또는 result = sum(range(1, n + 1)) # Σᵢ₌₁ⁿ xᵢ² → 각 원소를 제곱해서 다 더하기 x = [1, 2, 3, 4, 5] result = sum(xi**2 for xi in x) # = 1+4+9+16+25 = 55

# f: ℤ → ℤ, f(x) = x² # 정의역: 정수 전체 # 공역: 정수 전체 # 치역: 0, 1, 4, 9, 16, ... (음수는 나올 수 없음) def f(x: int) -> int: return x ** 2

A = {1, 2, 3, 4} B = {3, 4, 5, 6} # 합집합 (Union): A ∪ B — A 또는 B에 있는 원소 union = A | B # {1, 2, 3, 4, 5, 6} # 교집합 (Intersection): A ∩ B — A와 B 모두에 있는 원소 intersect = A & B # {3, 4} # 차집합 (Difference): A \ B — A에는 있지만 B에는 없는 원소 diff = A - B # {1, 2} # 대칭차집합 (Symmetric Difference): A △ B — 한쪽에만 있는 원소 sym_diff = A ^ B # {1, 2, 5, 6} # 부분집합 확인 print({1, 2} <= A) # True (⊆) print({1, 2} < A) # True (⊊, 진부분집합)

A = {1, 2, 3, 4, 5} print(len(A)) # |A| = 5 # 유한집합: len()으로 셀 수 있음 # 무한집합: 자연수 ℕ, 정수 ℤ, 실수 ℝ # |ℕ| < |ℝ| — 실수가 자연수보다 '더 큰' 무한 (칸토어의 대각선 논법)

-- UNION : A ∪ B SELECT id FROM table_a UNION SELECT id FROM table_b; -- INTERSECT : A ∩ B SELECT id FROM table_a INTERSECT SELECT id FROM table_b; -- EXCEPT : A \ B SELECT id FROM table_a EXCEPT SELECT id FROM table_b;

# f(x) = 2x 는 단사함수 # f(1)=2, f(2)=4, f(3)=6 → 출력이 겹치지 않음 # 역함수가 존재하려면 단사여야 함 # 암호화 함수는 반드시 단사여야 복호화가 가능함 def is_injective(func, domain): outputs = [func(x) for x in domain] return len(outputs) == len(set(outputs)) # 중복 없으면 단사

# f: {1,2,3} → {a,b}에서 # f(1)=a, f(2)=a, f(3)=b → 전사 (a,b 모두 커버) # f(1)=a, f(2)=a, f(3)=a → 전사 아님 (b 미커버) # 해시 함수(Hash Function): # 무한한 입력 → 유한한 출력 → 전사지만 단사가 아님 (충돌 발생)

# 전단사이면 역함수가 유일하게 존재함 # 예: f(x) = x + 1 → f⁻¹(y) = y - 1 # 암호화에서 전단사: # 평문 → 암호문 (전단사) → 역함수로 복호화 가능 # RSA, AES 같은 대칭/비대칭 암호화 모두 전단사 기반

import numpy as np # 벡터: 방향과 크기를 가진 수의 배열 # 실무에서는 '데이터 포인트 하나'를 벡터로 표현함 # 예: 사용자 [나이=25, 구매횟수=3, 평점=4.5] → [25, 3, 4.5] v = np.array([3, 4]) # 2차원 벡터 u = np.array([1, 2]) # 벡터 덧셈: 성분별 덧셈 print(v + u) # [4, 6] # 스칼라 곱: 벡터 크기 조절 print(2 * v) # [6, 8] # 벡터의 크기 (노름, Norm): ||v|| = √(3²+4²) = 5 norm = np.linalg.norm(v) print(norm) # 5.0 # 내적 (Dot Product): v · u = 3×1 + 4×2 = 11 # 두 벡터의 유사도를 측정하는 데 사용 dot = np.dot(v, u) print(dot) # 11 # 코사인 유사도: 두 벡터가 얼마나 같은 방향인지 (AI 추천 시스템) cosine_similarity = np.dot(v, u) / (np.linalg.norm(v) * np.linalg.norm(u)) print(cosine_similarity) # 0.9838... (1에 가까울수록 유사)

import numpy as np # 행렬: 벡터를 행(row)으로 쌓은 2D 배열 # 신경망 레이어 하나 = 입력 벡터 × 가중치 행렬 + 편향 A = np.array([[1, 2], [3, 4]]) B = np.array([[5, 6], [7, 8]]) # 행렬 덧셈: 같은 위치 성분끼리 print(A + B) # [[6, 8], # [10, 12]] # 행렬 곱셈 (Matrix Multiplication): 핵심 연산 # C[i][j] = A의 i번째 행 · B의 j번째 열의 내적 print(A @ B) # np.matmul(A, B)와 동일 # [[19, 22], # [43, 50]] # 전치행렬 (Transpose): 행과 열 교환 print(A.T) # [[1, 3], # [2, 4]] # 신경망 순전파 예시 # 입력 x (배치 크기 4, 특성 3) x = np.random.randn(4, 3) # (4, 3) 행렬 # 가중치 W (특성 3 → 은닉 5) W = np.random.randn(3, 5) # (3, 5) 행렬 # 편향 b b = np.zeros(5) # (5,) 벡터 # 순전파: z = xW + b z = x @ W + b # (4, 5) 행렬 print(z.shape) # (4, 5)

import numpy as np A = np.array([[2, 1], [5, 3]]) # 행렬식 (Determinant): det(A) # det(A) ≠ 0 이면 역행렬 존재 (선형 독립) det = np.linalg.det(A) print(f"det(A) = {det:.1f}") # 1.0 # 역행렬 (Inverse): A⁻¹, A × A⁻¹ = I (단위행렬) A_inv = np.linalg.inv(A) print(A_inv) # [[ 3, -1], # [-5, 2]] # 연립방정식 Ax = b 풀기 # 2x + y = 4 # 5x + 3y = 7 b = np.array([4, 7]) x = np.linalg.solve(A, b) print(x) # [5. -6.] → x=5, y=-6

import numpy as np # 확률 P(A): 사건 A가 일어날 가능성 (0 ≤ P(A) ≤ 1) # P(A) + P(A의 여사건) = 1 # 조건부 확률: P(A|B) = P(A∩B) / P(B) # "B가 주어졌을 때 A의 확률" # 예: 스팸 메일(B)이 주어졌을 때 '무료'(A)가 포함될 확률 # 베이즈 정리: P(A|B) = P(B|A) × P(A) / P(B) # 머신러닝에서 사후 확률(Posterior) 계산에 핵심 # 스팸 필터, 의료 진단, 자연어처리에 광범위하게 활용 # 시뮬레이션: 동전 1000번 던지기 flips = np.random.choice(['H', 'T'], size=1000) heads = np.sum(flips == 'H') print(f"앞면: {heads}/1000 = {heads/1000:.3f}") # 약 0.5

import numpy as np data = np.array([2, 4, 4, 4, 5, 5, 7, 9]) # 평균 (Mean): 데이터의 중심 mean = np.mean(data) # 5.0 # 분산 (Variance): 데이터가 평균에서 얼마나 퍼져있는지 # Var(X) = E[(X - μ)²] = Σ(xᵢ - μ)² / n var = np.var(data) # 4.0 # 표준편차 (Standard Deviation): 분산의 제곱근, 원래 단위와 동일 std = np.std(data) # 2.0 # 중앙값 (Median): 정렬 후 가운데 값 (이상치에 강건) median = np.median(data) # 4.5 print(f"평균: {mean}, 분산: {var}, 표준편차: {std}, 중앙값: {median}") # 정규화 (Normalization) vs 표준화 (Standardization) # 머신러닝 전처리에서 필수 # Min-Max 정규화: 0~1 사이로 조정 normalized = (data - data.min()) / (data.max() - data.min()) print(normalized) # Z-score 표준화: 평균=0, 표준편차=1 로 조정 standardized = (data - mean) / std print(standardized)

import numpy as np import random # 베르누이 분포: 결과가 0 또는 1인 실험 # P(X=1) = p, P(X=0) = 1-p # 예: 이진 분류 모델의 출력 # 이항 분포: n번 베르누이 시행 중 성공 횟수 # 예: 100개 메일 중 스팸 개수 trials, p = 100, 0.3 results = np.random.binomial(trials, p, size=1000) print(f"평균 스팸 수: {results.mean():.1f}") # ≈ 30 # 정규분포 (가우시안): N(μ, σ²) # 자연현상 대부분이 정규분포를 따름 # 딥러닝 가중치 초기화 시 사용 weights = np.random.normal(loc=0, scale=0.01, size=(100, 100)) print(f"가중치 평균: {weights.mean():.4f}, 표준편차: {weights.std():.4f}") # 소프트맥스: 다중 클래스 확률로 변환 (분류 모델 출력층) def softmax(x): exp_x = np.exp(x - np.max(x)) # 오버플로 방지 return exp_x / exp_x.sum() logits = np.array([2.0, 1.0, 0.1]) probs = softmax(logits) print(probs) # [0.659, 0.242, 0.099] print(probs.sum()) # 1.0

# f(x) = x² → f'(x) = 2x # f'(x): x에서 함수의 기울기 (순간 변화율) # 수치 미분: 아주 작은 h를 이용해 근사 def numerical_diff(f, x, h=1e-5): return (f(x + h) - f(x - h)) / (2 * h) f = lambda x: x ** 2 df = lambda x: 2 * x # 해석적 미분 x = 3.0 print(f"수치 미분: {numerical_diff(f, x):.5f}") # ≈ 6.0 print(f"해석 미분: {df(x)}") # 6.0 # 연쇄 법칙 (Chain Rule): 합성함수 미분 # d/dx f(g(x)) = f'(g(x)) × g'(x) # 딥러닝 역전파(Backpropagation)의 수학적 기반

import numpy as np # 편미분: 여러 변수 중 하나만 변화시켰을 때의 변화율 # ∂f/∂x: x에 대한 편미분 (다른 변수는 상수 취급) # f(x, y) = x² + 2xy + y² # ∂f/∂x = 2x + 2y # ∂f/∂y = 2x + 2y def f(x, y): return x**2 + 2*x*y + y**2 def partial_x(x, y, h=1e-5): return (f(x + h, y) - f(x - h, y)) / (2 * h) def partial_y(x, y, h=1e-5): return (f(x, y + h) - f(x, y - h)) / (2 * h) x, y = 2.0, 3.0 print(f"∂f/∂x = {partial_x(x, y):.2f}") # 2×2 + 2×3 = 10.0 print(f"∂f/∂y = {partial_y(x, y):.2f}") # 2×2 + 2×3 = 10.0

import numpy as np # 그래디언트(∇f): 모든 편미분을 벡터로 모은 것 # ∇f = [∂f/∂x₁, ∂f/∂x₂, ..., ∂f/∂xₙ] # 그래디언트 방향 = 함수가 가장 빠르게 증가하는 방향 # 경사하강법 (Gradient Descent): 손실을 최소화하는 파라미터 탐색 # θ ← θ - α × ∇L(θ) # θ: 파라미터, α: 학습률(learning rate), L: 손실함수 def gradient_descent_demo(): # f(x) = x² - 4x + 4 = (x-2)² → 최솟값: x=2 def f(x): return x**2 - 4*x + 4 def df(x): return 2*x - 4 # 해석적 그래디언트 x = 10.0 # 시작점 alpha = 0.1 # 학습률 for step in range(30): grad = df(x) x = x - alpha * grad # 그래디언트 반대 방향으로 이동 if step % 5 == 0: print(f"step {step:2d}: x = {x:.4f}, f(x) = {f(x):.6f}") print(f"\n최솟값 근사: x = {x:.4f} (정답: x = 2.0)") gradient_descent_demo() # step 0: x = 8.8000, f(x) = 47.0000 # step 5: x = 4.2634, f(x) = 5.0416 # step 10: x = 2.8670, f(x) = 0.7516 # step 15: x = 2.2884, f(x) = 0.0832 # ... # 최솟값 근사: x = 2.0002 (정답: x = 2.0)