거리와 비지도 학습

07장의 트리는 ”x≤x \le 임계값인가?”라는 질문으로 데이터를 나눴다. 이 장은 다른 생각 하나에서 출발한다. 가까운 것은 비슷하다. 표본을 특성 공간의 점으로 보고 점 사이의 거리를 재면, 정답이 있을 때는 가까운 이웃의 정답을 빌려 예측하고(kNN), 정답이 없을 때는 가까운 점끼리 묶고(k-평균), 점들이 가장 넓게 퍼진 방향만 남겨 차원을 줄이고(PCA), 질문과 방향이 가장 비슷한 문서를 찾는다(코사인 유사도 검색). 마지막 것은 17장 임베딩 검색과 RAG의 바탕이다. 네 방법 모두 “거리를 어떻게 재느냐”에 결과가 달려 있으므로, 단위와 차원이 거리를 어떻게 바꾸는지를 먼저 본다.

8-1. 이 장의 목표와 완료 기준

섹션 제목: “8-1. 이 장의 목표와 완료 기준”
목표 완료 기준
거리를 잰다 유클리드·맨해튼 거리를 계산하고, 모든 쌍의 거리를 행렬곱으로 구해 sklearn과 맞춘다
단위의 영향을 안다 표준화 전후에 거리를 차지하는 특성이 어떻게 바뀌는지 말한다
kNN을 쓴다 kNN을 NumPy로 구현해 sklearn과 맞추고, 표준화와 k를 교차검증으로 고른다
차원의 저주를 말한다 차원이 커지면 가장 가까운 점과 가장 먼 점의 거리가 비슷해지는 것을 수치로 보인다
k-평균을 쓴다 할당·평균 갱신을 직접 구현해 sklearn과 맞추고, n_init·inertia·실루엣 점수로 결과를 고른다
k-평균의 한계를 안다 둥글지 않은 군집·단위 차이에서 실패하는 예를 들고, 군집이 정답이 아님을 말한다
PCA를 쓴다 훈련 데이터에만 맞춘 PCA로 투영·복원하고, 설명된 분산 비율로 성분 수를 정하고, 2차원 그림을 읽는다
코사인 유사도로 검색한다 벡터를 정규화해 행렬곱 한 번으로 유사도를 구하고 상위 k개를 찾는다
선택 기준표에 줄을 더한다 거리 기반 방법을 언제 고르는지 적는다
실습 노트북 08을 끝낸다 실습/문제/ch08_거리와_비지도_학습.ipynb의 점검 셀이 모두 “통과”를 출력한다

예상 시간: 원고 1시간 30분, 실습 1시간 30분.

8-2. 왜 거리인가

섹션 제목: “8-2. 왜 거리인가”

8-3. 거리와 단위

섹션 제목: “8-3. 거리와 단위”

유클리드 거리와 맨해튼 거리

섹션 제목: “유클리드 거리와 맨해튼 거리”

두 점 aa, bb의 유클리드 거리(Euclidean distance)는 차이 벡터의 길이 ∑j(aj−bj)2\sqrt{\sum_j (a_j - b_j)^2}, 02장의 L2 노름 ∥a−b∥\lVert a - b \rVert이다. 맨해튼 거리(Manhattan distance)는 차이의 절댓값 합 ∑j∣aj−bj∣\sum_j \lvert a_j - b_j \rvert, L1 노름이다. 바둑판 길을 따라 걷는 거리라 이렇게 부른다.

import numpy as np
from sklearn.metrics import pairwise_distances
a = np.array([1.0, 2.0, 3.0])
b = np.array([4.0, 0.0, 3.0])
print("유클리드", np.linalg.norm(a - b), np.sqrt(np.sum((a - b) ** 2)))
print("맨해튼 ", np.abs(a - b).sum(), pairwise_distances([a], [b], metric="manhattan")[0, 0])
출력
유클리드 3.605551275463989 3.605551275463989
맨해튼 5.0 5.0

단위가 거리를 바꾼다

섹션 제목: “단위가 거리를 바꾼다”

sklearn의 와인 데이터(load_wine)는 와인 178병의 화학 성분 13개로 품종 3개를 구분한다. 특성마다 단위가 다르다.

from sklearn.datasets import load_wine
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
wine = load_wine()
Xw, yw = wine.data, wine.target
w_tr, w_va, yw_tr, yw_va = train_test_split(Xw, yw, test_size=0.3, stratify=yw, random_state=0)
print(Xw.shape, "품종별 개수", np.bincount(yw))
for j in [0, 7, 12]:
print(f"{wine.feature_names[j]:21s} 표준편차 {w_tr[:, j].std():8.2f}")
sc = StandardScaler().fit(w_tr) # 훈련 데이터에만 맞춘다(05장)
z_tr = sc.transform(w_tr)
d2_raw = (w_tr[0] - w_tr[1]) ** 2 # 특성별 차이²
d2_std = (z_tr[0] - z_tr[1]) ** 2
print("proline이 거리²에서 차지하는 비율: 원래", round(d2_raw[12] / d2_raw.sum(), 3), "/ 표준화 뒤", round(d2_std[12] / d2_std.sum(), 3))
출력
(178, 13) 품종별 개수 [59 71 48]
alcohol 표준편차 0.82
nonflavanoid_phenols 표준편차 0.12
proline 표준편차 325.39
proline이 거리²에서 차지하는 비율: 원래 0.997 / 표준화 뒤 0.132

수학 상자: 모든 쌍의 거리를 행렬곱으로

섹션 제목: “수학 상자: 모든 쌍의 거리를 행렬곱으로”

kNN·k-평균·검색은 “점 m개와 점 n개 사이의 모든 거리”가 필요하다. 이중 for 문 대신 다음 전개를 쓴다.

∥a−b∥2=∥a∥2+∥b∥2−2 a⋅b\lVert a - b \rVert^2 = \lVert a \rVert^2 + \lVert b \rVert^2 - 2\, a \cdot b

from sklearn.metrics.pairwise import euclidean_distances
def sq_dists(A, B): # (m, d), (n, d) → (m, n) 거리²
D2 = (A ** 2).sum(axis=1)[:, None] + (B ** 2).sum(axis=1)[None, :] - 2 * A @ B.T
return np.maximum(D2, 0) # 반올림 오차로 생긴 −0.0000001 같은 값을 0으로
loop = np.array([[np.sum((p - q) ** 2) for q in z_tr[:5]] for p in z_tr[:3]])
print(sq_dists(z_tr[:3], z_tr[:5]).shape,
np.allclose(sq_dists(z_tr[:3], z_tr[:5]), loop),
np.allclose(sq_dists(z_tr, z_tr), euclidean_distances(z_tr, z_tr, squared=True)))
출력
(3, 5) True True

8-4. kNN: 가까운 이웃의 다수결

섹션 제목: “8-4. kNN: 가까운 이웃의 다수결”

직접 구현과 sklearn

섹션 제목: “직접 구현과 sklearn”

k-최근접 이웃(k-nearest neighbors, kNN) 분류는 새 표본과 거리가 가장 가까운 훈련 표본 k개를 찾아 그 정답의 다수결로 예측한다. 회귀(KNeighborsRegressor)는 이웃 정답의 평균을 낸다. “학습”은 훈련 데이터를 저장하는 것(설정에 따라 빠른 검색용 트리를 만드는 것까지)이다. sklearn에서 훈련 표본을 더하려면 기존 표본과 합쳐 다시 fit한다.

from sklearn.neighbors import KNeighborsClassifier
def knn_predict(X_tr, y_tr, X_new, k):
nn = np.argsort(sq_dists(X_new, X_tr), axis=1)[:, :k] # 행마다 가까운 k개의 위치
return np.array([np.bincount(y_tr[row]).argmax() for row in nn]) # 다수결(동점이면 작은 범주)
z_va = sc.transform(w_va)
mine = knn_predict(z_tr, yw_tr, z_va, k=5)
knn = KNeighborsClassifier(n_neighbors=5).fit(z_tr, yw_tr)
print("sklearn과 같은 예측:", np.array_equal(mine, knn.predict(z_va)), "/ 검증 정확도", round(np.mean(mine == yw_va), 3))
print("이웃 5개의 정답:", yw_tr[knn.kneighbors(z_va[:1])[1][0]], "→ 예측", knn.predict(z_va[:1])[0], "/ 확률", knn.predict_proba(z_va[:1])[0])
출력
sklearn과 같은 예측: True / 검증 정확도 0.963
이웃 5개의 정답: [0 0 0 0 0] → 예측 0 / 확률 [1. 0. 0.]

표준화를 빼면

섹션 제목: “표준화를 빼면”
from sklearn.pipeline import make_pipeline
raw = KNeighborsClassifier(n_neighbors=5).fit(w_tr, yw_tr)
scaled = make_pipeline(StandardScaler(), KNeighborsClassifier(n_neighbors=5)).fit(w_tr, yw_tr)
print(f"표준화 없음: 검증 {raw.score(w_va, yw_va):.3f} / 표준화: 검증 {scaled.score(w_va, yw_va):.3f}")
출력
표준화 없음: 검증 0.722 / 표준화: 검증 0.963

k 고르기: 편향과 분산

섹션 제목: “k 고르기: 편향과 분산”
from sklearn.model_selection import StratifiedKFold, cross_val_score
cv = StratifiedKFold(n_splits=5, shuffle=True, random_state=0)
print(" k 훈련 교차검증")
for k in [1, 5, 15, 31, 61, 91]:
model = make_pipeline(StandardScaler(), KNeighborsClassifier(n_neighbors=k))
tr = model.fit(w_tr, yw_tr).score(w_tr, yw_tr)
print(f"{k:3d} {tr:6.3f} {cross_val_score(model, w_tr, yw_tr, cv=cv).mean():8.3f}")
출력
k 훈련 교차검증
1 1.000 0.919
5 0.968 0.951
15 0.952 0.943
31 0.976 0.952
61 0.952 0.831
91 0.661 0.403
kNN은 k가 작으면 경계가 구불구불하고 크면 매끈하다. k-평균은 둥근 덩어리는 잘 나누지만 반달은 직선으로 자른다kNN은 k가 작으면 경계가 구불구불하고 크면 매끈하다. k-평균은 둥근 덩어리는 잘 나누지만 반달은 직선으로 자른다

그림 설명. 네 칸 모두 좌표축 눈금은 생략했다. 첫째·둘째 칸은 07장의 반달 데이터(훈련 300개, 회색 점이 0, 빨간 삼각형이 1)에 kNN을 학습한 결정 영역이고, 붉은 영역이 1로 예측하는 곳이다. k = 1은 경계가 표본 하나하나를 따라 구불구불하고 상대 영역 안에 작은 섬이 생긴다(훈련 1.000, 검증 0.833). k = 30은 경계가 매끈한 곡선이 된다(훈련 0.883, 검증 0.857). 셋째 칸은 둥근 덩어리 4개(400개)에 k-평균 k = 4를 돌린 결과로, 덩어리마다 한 색이고 × 표시한 중심이 각 덩어리 가운데에 있다. 넷째 칸은 잡음이 적은 반달 2개(400개)에 k-평균 k = 2를 돌린 결과다. 두 무리가 반달 모양을 따르지 못하고 비스듬한 직선 하나로 갈려, 각 무리에 다른 반달의 일부가 섞인다.

차원의 저주

섹션 제목: “차원의 저주”

정답과 무관한 특성이 많아지면 거리가 흐려진다. 극단적인 경우로, 서로 독립인 무작위 특성만 있을 때 차원을 늘려 본다. 0~1 사이 균등 분포에서 점 500개를 뽑고, 새 점 하나에서 가장 가까운 점과 가장 먼 점의 거리를 비교한다.

rng = np.random.default_rng(0)
print("차원 최근접 최원 비율")
for d in [2, 10, 100, 1000]:
P, q = rng.uniform(size=(500, d)), rng.uniform(size=d)
dist = np.linalg.norm(P - q, axis=1)
print(f"{d:4d} {dist.min():7.2f} {dist.max():6.2f} {dist.min() / dist.max():6.3f}")
출력
차원 최근접 최원 비율
2 0.03 1.27 0.024
10 0.34 1.91 0.177
100 3.39 4.60 0.737
1000 12.32 13.63 0.904

8-5. k-평균 군집

섹션 제목: “8-5. k-평균 군집”

할당과 평균 갱신을 되풀이한다

섹션 제목: “할당과 평균 갱신을 되풀이한다”

k-평균(k-means)은 정답 없이 점들을 k개 무리로 나눈다. 각 무리의 대표점을 중심(centroid)이라 한다.

  1. 중심 k개를 정한다(예: 표본 k개를 무작위로 고른다).
  2. 할당: 모든 점을 가장 가까운 중심의 무리에 넣는다.
  3. 갱신: 각 중심을 그 무리 점들의 평균으로 옮긴다.
  4. 할당이 더 바뀌지 않을 때까지(또는 반복 상한까지) 2~3을 되풀이한다.
from sklearn.datasets import make_blobs
from sklearn.cluster import KMeans
Xb, yb = make_blobs(n_samples=400, centers=4, cluster_std=0.8, random_state=6)
def kmeans(X, C, max_iter=100):
labels = None
for it in range(1, max_iter + 1):
new = sq_dists(X, C).argmin(axis=1) # 할당: 가장 가까운 중심
if labels is not None and np.array_equal(new, labels):
break # 할당이 그대로면 끝
labels = new
C = np.array([X[labels == j].mean(axis=0) for j in range(len(C))]) # 갱신: 무리의 평균
labels = sq_dists(X, C).argmin(axis=1) # 최종 중심으로 다시 할당(상한에서 끝날 때 대비)
inertia = sq_dists(X, C)[np.arange(len(X)), labels].sum()
return labels, C, inertia, it
C0 = Xb[np.random.default_rng(0).choice(len(Xb), 4, replace=False)] # 처음 중심: 표본 4개
labels, C, inertia, it = kmeans(Xb, C0)
km = KMeans(n_clusters=4, init=C0, n_init=1, tol=0).fit(Xb) # tol=0: 할당이 그대로일 때까지
print("반복", it, "/ inertia 직접", round(inertia, 1), "sklearn", round(km.inertia_, 1))
print("같은 할당:", np.array_equal(labels, km.labels_), "/ 같은 중심:", np.allclose(C, km.cluster_centers_))
출력
반복 4 / inertia 직접 473.0 sklearn 473.0
같은 할당: True / 같은 중심: True

처음 중심에 따라 결과가 다르다

섹션 제목: “처음 중심에 따라 결과가 다르다”
print("처음 중심(seed)별 inertia:", [round(KMeans(4, init="random", n_init=1, random_state=s).fit(Xb).inertia_, 1) for s in range(6)])
best = KMeans(4, init="random", n_init=10, random_state=0).fit(Xb)
print("n_init=10의 inertia:", round(best.inertia_, 1))
출력
처음 중심(seed)별 inertia: [473.0, 473.0, 4539.5, 2184.1, 473.0, 473.0]
n_init=10의 inertia: 473.0

k 고르기: inertia와 실루엣 점수

섹션 제목: “k 고르기: inertia와 실루엣 점수”
from sklearn.metrics import silhouette_score
print(" k inertia 실루엣")
for k in range(2, 8):
m = KMeans(n_clusters=k, n_init=10, random_state=0).fit(Xb)
print(f"{k:2d} {m.inertia_:9.1f} {silhouette_score(Xb, m.labels_):7.3f}")
출력
k inertia 실루엣
2 6352.7 0.623
3 2228.9 0.699
4 473.0 0.799
5 427.9 0.670
6 386.2 0.554
7 346.7 0.426

한계: 모양과 단위, 그리고 정답이 아니다

섹션 제목: “한계: 모양과 단위, 그리고 정답이 아니다”
from sklearn.datasets import make_moons
from sklearn.metrics import adjusted_rand_score
Xm, ym = make_moons(n_samples=400, noise=0.05, random_state=0)
km_m = KMeans(n_clusters=2, n_init=10, random_state=0).fit(Xm)
print("반달 2개: 실제 무리와의 일치(ARI)", round(adjusted_rand_score(ym, km_m.labels_), 3))
print("덩어리 4개: 실제 무리와의 일치(ARI)", round(adjusted_rand_score(yb, best.labels_), 3))
출력
반달 2개: 실제 무리와의 일치(ARI) 0.274
덩어리 4개: 실제 무리와의 일치(ARI) 1.0

8-6. PCA: 가장 넓게 퍼진 방향

섹션 제목: “8-6. PCA: 가장 넓게 퍼진 방향”

주성분

섹션 제목: “주성분”

특성이 2개인 점들이 비스듬한 타원 모양으로 퍼져 있다고 하자. 축을 돌려 점들이 가장 넓게 퍼진 방향을 첫째 축으로, 그와 직각인 방향 중 가장 넓게 퍼진 방향을 둘째 축으로 삼는다. 이 축들을 주성분(principal component)이라 하고, 이렇게 축을 바꾸는 방법이 주성분 분석(principal component analysis, PCA)이다. 뒤쪽 주성분 몇 개를 버리면 정보를 조금 잃고 차원을 줄인다.

sklearn PCA로 주성분을 구하고, 바꾼 좌표가 어떻게 계산되는지 확인한다.

from sklearn.decomposition import PCA
rng = np.random.default_rng(0)
x1 = rng.normal(0, 2, 300)
X2 = np.column_stack([x1, 0.5 * x1 + rng.normal(0, 0.5, 300)]) # 비스듬한 타원
pca2 = PCA().fit(X2)
print("주성분(행)", pca2.components_.round(3).tolist())
print("주성분별 분산", pca2.explained_variance_.round(3), "/ 설명된 분산 비율", pca2.explained_variance_ratio_.round(3))
Z2 = pca2.transform(X2)
print("transform = (X − 평균) @ 주성분ᵀ:", np.allclose(Z2, (X2 - pca2.mean_) @ pca2.components_.T))
print("변환 뒤 상관계수", np.corrcoef(Z2.T)[0, 1].round(6), "/ 열별 분산", Z2.var(axis=0, ddof=1).round(3))
출력
주성분(행) [[0.882, 0.471], [-0.471, 0.882]]
주성분별 분산 [5.291 0.187] / 설명된 분산 비율 [0.966 0.034]
transform = (X − 평균) @ 주성분ᵀ: True
변환 뒤 상관계수 0.0 / 열별 분산 [5.291 0.187]

64차원 손글씨를 2차원으로

섹션 제목: “64차원 손글씨를 2차원으로”

sklearn 내장 손글씨 숫자(load_digits)는 8×8 픽셀 이미지 1797장이다. 펼치면 특성이 64개다.

from sklearn.datasets import load_digits
digits = load_digits()
Xd, yd = digits.data, digits.target
pca_d = PCA().fit(Xd)
cum = np.cumsum(pca_d.explained_variance_ratio_)
print(Xd.shape, "/ 처음 2개", cum[1].round(3), "/ 10개", cum[9].round(3), "/ 20개", cum[19].round(3))
print("90%에 필요한 주성분 수", np.searchsorted(cum, 0.90) + 1, "/ 95%", np.searchsorted(cum, 0.95) + 1)
print("PCA(n_components=0.9):", PCA(n_components=0.9).fit(Xd).n_components_)
출력
(1797, 64) / 처음 2개 0.285 / 10개 0.738 / 20개 0.894
90%에 필요한 주성분 수 21 / 95% 29
PCA(n_components=0.9): 21
손글씨 숫자를 주성분 2개로 그리면 0·3·4·6은 갈라지고 1·5·7·8은 가운데서 겹친다. 분산 90%는 21개, 95%는 29개로 담긴다손글씨 숫자를 주성분 2개로 그리면 0·3·4·6은 갈라지고 1·5·7·8은 가운데서 겹친다. 분산 90%는 21개, 95%는 29개로 담긴다

그림 설명. 왼쪽은 손글씨 숫자 1797장을 가로축 주성분 1(분산의 14.9%), 세로축 주성분 2(13.6%)에 찍은 산점도다. 숫자마다 색을 다르게 하고, 그 숫자 점들의 가운데에 숫자를 적었다. 0은 아래, 4는 오른쪽, 6은 오른쪽 아래, 3은 왼쪽, 9는 왼쪽 아래에 비교적 따로 모이고, 1·5·7·8과 2는 가운데에서 서로 겹친다. 오른쪽은 가로축 남기는 주성분 수(1~64), 세로축 누적 설명된 분산 비율(0~1)이다. 곡선은 처음에 가파르게 오르다 완만해지며, 점선 표시처럼 90%는 21개, 95%는 29개에서 넘는다.

줄인 뒤 모델에 넣기

섹션 제목: “줄인 뒤 모델에 넣기”
d_tr, d_va, yd_tr, yd_va = train_test_split(Xd, yd, test_size=0.3, stratify=yd, random_state=0)
for name, model in [("kNN(64차원) ", KNeighborsClassifier(n_neighbors=5)),
("PCA 20 + kNN ", make_pipeline(PCA(n_components=20), KNeighborsClassifier(n_neighbors=5))),
("PCA 2 + kNN ", make_pipeline(PCA(n_components=2), KNeighborsClassifier(n_neighbors=5)))]:
print(name, "검증 정확도", round(model.fit(d_tr, yd_tr).score(d_va, yd_va), 3))
p20 = PCA(n_components=20).fit(d_tr)
back = p20.inverse_transform(p20.transform(d_va)) # 20차원으로 줄였다가 64차원으로 되돌림
print("복원 평균 제곱 오차", round(np.mean((back - d_va) ** 2), 3), "/ 픽셀 분산 평균", round(d_va.var(axis=0).mean(), 3))
출력
kNN(64차원) 검증 정확도 0.98
PCA 20 + kNN 검증 정확도 0.974
PCA 2 + kNN 검증 정확도 0.606
복원 평균 제곱 오차 2.096 / 픽셀 분산 평균 18.887

표준화와 PCA

섹션 제목: “표준화와 PCA”
p_raw = PCA().fit(w_tr)
p_std = make_pipeline(StandardScaler(), PCA()).fit(w_tr)[-1]
print("와인 첫 주성분이 설명한 분산: 원래", p_raw.explained_variance_ratio_[0].round(3),
"/ 표준화 뒤", p_std.explained_variance_ratio_[0].round(3))
print("원래 단위 첫 주성분에서 가장 큰 성분:", wine.feature_names[np.abs(p_raw.components_[0]).argmax()])
출력
와인 첫 주성분이 설명한 분산: 원래 0.998 / 표준화 뒤 0.37
원래 단위 첫 주성분에서 가장 큰 성분: proline

8-7. 코사인 유사도와 최근접 검색

섹션 제목: “8-7. 코사인 유사도와 최근접 검색”

길이 말고 방향

섹션 제목: “길이 말고 방향”

코사인 유사도(cosine similarity)는 두 벡터 사이 각도의 코사인이다.

cos⁡(a,b)=a⋅b∥a∥ ∥b∥\cos(a, b) = \frac{a \cdot b}{\lVert a \rVert \, \lVert b \rVert}

두 벡터가 모두 영벡터가 아닐 때 정의되고, 방향이 같으면 1, 직각이면 0, 반대면 −1이다. 길이는 보지 않는다. 문서를 “단어(또는 글자 묶음)별 등장 횟수” 벡터로 만들면, 같은 내용을 두 번 이어 쓴 문서는 벡터 길이만 두 배가 된다. 내용이 같으니 같다고 봐야 한다.

def cosine(a, b):
return a @ b / (np.linalg.norm(a) * np.linalg.norm(b))
doc = np.array([2.0, 1.0, 0.0, 3.0]) # 단어 4종의 등장 횟수
print("두 번 이어 쓴 문서: 유클리드", np.linalg.norm(doc - 2 * doc).round(3), "/ 코사인", cosine(doc, 2 * doc).round(3))
print("겹치는 단어 없음 : 코사인", cosine(doc, np.array([0.0, 0.0, 5.0, 0.0])))
출력
두 번 이어 쓴 문서: 유클리드 3.742 / 코사인 1.0
겹치는 단어 없음 : 코사인 0.0

정규화하면 행렬곱 한 번

섹션 제목: “정규화하면 행렬곱 한 번”

FAQ 문장 6개 중 질문과 가장 비슷한 것을 찾는다. 문장을 글자 두 개씩 묶은 조각(예: “배송은” → “배송”, “송은”. 단어 앞뒤에는 공백을 붙여 ” 배”, “은 “도 센다)의 등장 횟수 벡터로 바꾼다. 한국어는 조사가 붙어 단어 단위로 세면 “배송은”과 “배송”이 다른 단어가 되기 때문이다. 이 방법은 같은 글자가 겹치는지만 볼 뿐 뜻은 모른다. 뜻을 담는 문장 임베딩은 17장에서 다룬다.

from sklearn.feature_extraction.text import CountVectorizer
from sklearn.neighbors import NearestNeighbors
faq = ["배송은 주문 후 2~3일 걸립니다", "환불은 수령 후 7일 안에 신청하세요", "교환하려면 고객센터에 연락하세요",
"배송 조회는 마이페이지에서 합니다", "쿠폰은 결제 화면에서 적용됩니다", "회원 등급은 매달 1일에 바뀝니다"]
queries = ["배송 며칠 걸려요", "환불 신청 기간", "쿠폰 어디서 써요"]
vec = CountVectorizer(analyzer="char_wb", ngram_range=(2, 2)).fit(faq) # 글자 2개 묶음의 등장 횟수
D = vec.transform(faq).toarray().astype(float)
Q = vec.transform(queries).toarray().astype(float)
print("벡터 모양", D.shape, Q.shape)
def normalize(M):
n = np.linalg.norm(M, axis=1, keepdims=True)
return M / np.where(n == 0, 1, n) # 행마다 길이 1로(영벡터는 0으로 둔다)
S = normalize(Q) @ normalize(D).T # (질문 3, 문서 6) 코사인 유사도
top = np.argsort(-S, axis=1, kind="stable")[:, :2] # 큰 순서 상위 2개(같으면 앞 번호)
for q, row, s in zip(queries, top, S):
print(f"{q} → {faq[row[0]]} ({s[row[0]]:.2f}) / {faq[row[1]]} ({s[row[1]]:.2f})")
nn = NearestNeighbors(n_neighbors=2, metric="cosine").fit(D)
dist, idx = nn.kneighbors(Q)
print("sklearn 코사인 거리 = 1 − 유사도:", np.allclose(1 - dist, np.take_along_axis(S, idx, axis=1)))
출력
벡터 모양 (6, 93) (3, 93)
배송 며칠 걸려요 → 배송은 주문 후 2~3일 걸립니다 (0.31) / 배송 조회는 마이페이지에서 합니다 (0.31)
환불 신청 기간 → 환불은 수령 후 7일 안에 신청하세요 (0.44) / 배송은 주문 후 2~3일 걸립니다 (0.00)
쿠폰 어디서 써요 → 쿠폰은 결제 화면에서 적용됩니다 (0.35) / 교환하려면 고객센터에 연락하세요 (0.12)
sklearn 코사인 거리 = 1 − 유사도: True

수학 상자: 정규화한 벡터의 거리와 코사인

섹션 제목: “수학 상자: 정규화한 벡터의 거리와 코사인”

길이가 1인 두 벡터 aa, bb에서는 8-3절의 전개가 이렇게 된다.

∥a−b∥2=∥a∥2+∥b∥2−2 a⋅b=2−2cos⁡(a,b)\lVert a - b \rVert^2 = \lVert a \rVert^2 + \lVert b \rVert^2 - 2\, a \cdot b = 2 - 2 \cos(a, b)

Dn = normalize(D)
print("거리² = 2 − 2·코사인:", np.allclose(sq_dists(normalize(Q), Dn), 2 - 2 * S))
출력
거리² = 2 − 2·코사인: True

8-8. 거리 기반 방법을 언제 쓰나

섹션 제목: “8-8. 거리 기반 방법을 언제 쓰나”
상황 고를 것 이유
의미 있는 특성 공간이 이미 있다(사전학습 모델이 뽑은 특성, 임베딩) kNN 또는 코사인 최근접 검색 따로 학습할 모델이 없고, 새 데이터는 합쳐서 다시 fit(저장)하면 된다
표 데이터 분류·회귀에서 성능이 필요하다 트리 앙상블(07장), kNN은 비교용 kNN은 단위·쓸모없는 특성·차원에 약하고 예측이 느리다
정답 없이 고객·문서를 몇 무리로 나누고 싶다 표준화 + k-평균(n_init 여러 번), 실루엣·업무 쓸모로 k 결정 둥근 무리를 빠르게 찾는다. 휘어진 무리는 DBSCAN 등
특성이 수십~수백 개인 데이터를 그림으로 보고 싶다 표준화 + PCA 2차원 가장 넓게 퍼진 두 방향으로 본다. 겹침은 2차원 한계일 수 있다
특성이 많아 kNN·거리 계산이 느리거나 흐리다 PCA로 설명 분산 90~95%만 남기고 검증 분산이 작은 방향을 버려 계산을 줄인다. 버린 방향이 잡음이라는 보장도, 정답과 무관하다는 보장도 없다
문서·문장의 비슷함 정규화 + 코사인 유사도 길이가 아니라 방향이 내용을 담는다

8-9. 선택 기준표에 추가

섹션 제목: “8-9. 선택 기준표에 추가”
상황 고를 것 이유 장
거리·유사도를 쓰는 모델(kNN·k-평균·PCA) 단위가 다른 특성은 표준화(훈련 데이터에만 fit) 단위가 큰 특성 하나가 거리와 분산을 독차지한다 08
kNN을 쓴다 표준화 + k를 교차검증으로 k가 작으면 분산, 크면 편향이 크다. 차원이 높으면 거리가 흐려진다 08
정답 없이 무리를 나눈다 k-평균(n_init 여러 번) + 실루엣·업무 쓸모로 k, 결과는 사람이 해석 처음 중심에 따라 결과가 다르고, 군집은 정답이 아니다 08
차원을 줄인다 PCA(설명된 분산 비율로 개수 결정, 성능은 검증) 분산이 큰 방향이 정답에 중요한 방향이라는 보장은 없다 08
비슷한 문서·벡터를 찾는다 L2 정규화 + 행렬곱 코사인 유사도, 동점 규칙을 정한다 방향이 내용을 담고, 정규화하면 행렬곱 한 번이다 08

확인 문제

섹션 제목: “확인 문제”

8-10. 실습과 문제

섹션 제목: “8-10. 실습과 문제”

실습/문제/ch08_거리와_비지도_학습.ipynb를 .venv 커널로 열고 위에서부터 푼다. 내려받기가 없고 CPU로 1분 안팎에 끝난다. 다 푼 뒤 해설 노트북과 비교한다.

번호 유형 내용
1 개념 거리·kNN 참/거짓
2 코드 모든 쌍의 거리²를 행렬곱으로
3 코드 kNN 분류 직접 구현
4 코드 표준화 + kNN의 k를 교차검증으로 고르기
5 코드 k-평균 직접 구현
6 코드 설명된 분산 비율로 주성분 수 고르기, PCA로 줄이고 복원하기
7 코드 코사인 유사도 상위 k개 검색
8 개념 k-평균·PCA 참/거짓
9 사례 연봉 하나로 갈린 고객 군집
10 사례 상황별 방법 고르기

8-11. 공식 문서와 참고 자료

섹션 제목: “8-11. 공식 문서와 참고 자료”