데이터를 숫자로: NumPy

01장에서 붓꽃 표와 손글씨 이미지를 모델에 넣었다. 그때 모델이 받은 것은 모두 NumPy 배열이었다. 모델은 숫자만 받는다. 표·사진·글은 모두 숫자 배열로 바뀐 뒤 모델에 들어간다. 이 장에서는 그 배열을 다루는 라이브러리 NumPy의 핵심 규칙 세 가지, 모양(shape)과 축(axis), 브로드캐스팅(broadcasting), 벡터화(vectorization)를 익히고, 표·이미지·텍스트가 각각 어떤 모양의 배열이 되는지 살펴본다.

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

섹션 제목: “2-1. 이 장의 목표와 완료 기준”
목표 완료 기준
배열의 shape·축·dtype을 읽는다 sum(axis=…), 인덱싱, reshape의 결과 shape를 실행 전에 맞힌다
브로드캐스팅 규칙을 쓴다 두 shape가 계산되는지, 결과 shape가 무엇인지 판단하고, 열별 표준화·행별 비율을 루프 없이 쓴다
반복 계산을 벡터화한다 거리·내적·코사인 유사도를 루프 대신 브로드캐스팅과 행렬곱으로 계산한다
데이터가 배열이 되는 방식을 안다 표·흑백/컬러 이미지·텍스트의 배열 모양을 말하고, 축 순서((H, W, C) ↔ (C, H, W))를 바꾼다
선택 기준표에 줄을 더한다 데이터 종류별로 어떤 배열 표현을 쓰고 무엇을 확인할지 고른다
실습 노트북 02를 끝낸다 실습/문제/ch02_데이터를_숫자로_NumPy.ipynb의 점검 셀이 모두 “통과”를 출력한다

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

2-2. 왜 NumPy인가

섹션 제목: “2-2. 왜 NumPy인가”

파이썬 리스트와 NumPy 배열은 같은 연산자에 다르게 반응한다.

import numpy as np
lst = [1, 2, 3]
arr = np.array([1, 2, 3])
print(lst * 2, arr * 2)
print(lst + [10], arr + 10)
출력
[1, 2, 3, 1, 2, 3] [2 4 6]
[1, 2, 3, 10] [11 12 13]

리스트의 *·+는 이어 붙이기이고, 배열에서는 원소마다 따로 계산한다.

2-3. 배열의 기본: shape·dtype

섹션 제목: “2-3. 배열의 기본: shape·dtype”
용어 뜻 확인
배열(ndarray) 같은 dtype 값이 격자 모양으로 놓인 묶음 type(a)
차원 수(ndim) 축의 개수 a.ndim
모양(shape) 축마다 길이를 적은 튜플 a.shape
크기(size) 전체 원소 수 = shape의 곱 a.size
자료형(dtype) 원소의 종류(int64, float32, uint8 등) a.dtype
a = np.array([[1, 2, 3], [4, 5, 6]])
print(a)
print("shape", a.shape, "ndim", a.ndim, "size", a.size, "dtype", a.dtype)
print(np.zeros((2, 3)))
print(np.arange(0, 10, 3), np.linspace(0, 1, 5))
rng = np.random.default_rng(0) # 난수 생성기. 같은 시드면 같은 수
print(rng.normal(size=(2, 3)).round(2))
출력
[[1 2 3]
[4 5 6]]
shape (2, 3) ndim 2 size 6 dtype int64
[[0. 0. 0.]
[0. 0. 0.]]
[0 3 6 9] [0. 0.25 0.5 0.75 1. ]
[[ 0.13 -0.13 0.64]
[ 0.1 -0.54 0.36]]

shape (2, 3)은 “축 0의 길이 2, 축 1의 길이 3”이다. 2차원이면 축 0이 행, 축 1이 열이다.

dtype 함정

섹션 제목: “dtype 함정”
x = np.array([1, 2, 3])
x[0] = 2.7
print(x) # 정수 배열에 실수를 넣으면 소수점이 잘린다
pix = np.array([200, 250], dtype=np.uint8) # 이미지 픽셀에 흔한 0~255 정수
print(pix + 100) # 255를 넘으면 256으로 나눈 나머지가 된다
print(pix.astype(np.float32) / 255) # 실수로 바꾼 뒤 계산
출력
[2 2 3]
[44 94]
[0.78431374 0.98039216]

uint8은 부호 없는 8비트 정수로 0~255만 담는다. 200+100이 44가 되어도 오류도 경고도 나지 않는다. 이미지 밝기를 바꾸거나 평균을 낼 때는 먼저 astype(np.float32)로 바꾼다.

2-4. shape와 축

섹션 제목: “2-4. shape와 축”
sum(axis=k)는 k번 축을 없애고, 브로드캐스팅은 길이 1인 축을 상대 길이만큼 늘려 계산한다sum(axis=k)는 k번 축을 없애고, 브로드캐스팅은 길이 1인 축을 상대 길이만큼 늘려 계산한다

그림 설명. 왼쪽은 0~11이 든 (3, 4) 배열 X다. 아래로 합친 sum(axis=0)은 열마다 하나씩 [12, 15, 18, 21] (4,)이 되어 축 0(행)이 사라진다. 옆으로 합친 sum(axis=1)은 행마다 하나씩 [6, 22, 38] (3,)이다. 오른쪽은 (3, 1)인 [0, 10, 20] 열과 (1, 4)인 [1, 2, 3, 4] 행을 더하는 브로드캐스팅이다. 흐린 칸은 길이 1인 축이 상대 길이만큼 늘어난 것처럼 계산되는 자리이고(실제 복사는 없다), 결과는 (3, 4) 배열 [[1, 2, 3, 4], [11, 12, 13, 14], [21, 22, 23, 24]]이다.

인덱싱과 슬라이싱

섹션 제목: “인덱싱과 슬라이싱”
X = np.arange(12).reshape(3, 4)
print(X)
print(X[1], X[:, 1], X[1, 2])
print(X[0:2, 1:3].shape, X[:, 1].shape, X[:, [1]].shape)
print(X[X % 2 == 0]) # 불리언 마스크: 조건에 맞는 원소만 1차원으로
print(X[[0, 2]]) # 정수 리스트: 0행과 2행
출력
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
[4 5 6 7] [1 5 9] 6
(2, 2) (3,) (3, 1)
[ 0 2 4 6 8 10]
[[ 0 1 2 3]
[ 8 9 10 11]]

X[:, 1]은 열 하나를 1차원 (3,)으로 꺼내고, X[:, [1]]은 2차원 (3, 1)을 유지한다. 정수 하나로 고른 축은 사라지고, 슬라이스나 리스트로 고른 축은 남는다.

축을 따라 집계하기

섹션 제목: “축을 따라 집계하기”

axis=k로 집계하면 k번 축이 사라진다. 2차원에서 axis=0은 “행들을 위아래로 합쳐 열마다 하나”, axis=1은 “열들을 옆으로 합쳐 행마다 하나”다.

print(X.sum(axis=0), X.sum(axis=0).shape)
print(X.sum(axis=1), X.sum(axis=1).shape)
print(X.sum(axis=1, keepdims=True).shape) # 사라질 축을 길이 1로 남긴다
imgs = np.zeros((10, 8, 8)) # 8×8 흑백 이미지 10장
print(imgs.mean(axis=0).shape, imgs.mean(axis=(1, 2)).shape)
출력
[12 15 18 21] (4,)
[ 6 22 38] (3,)
(3, 1)
(8, 8) (10,)

imgs.mean(axis=0)은 10장을 겹친 평균 이미지 (8, 8)이고, imgs.mean(axis=(1, 2))는 이미지마다 평균 밝기 (10,)이다. 같은 mean이라도 축에 따라 뜻이 전혀 다르다.

reshape와 transpose는 다르다

섹션 제목: “reshape와 transpose는 다르다”
print(X.reshape(4, 3))
print(X.T)
print(np.array_equal(X.reshape(4, 3), X.T))
print(X.reshape(-1).shape, X.reshape(2, -1).shape) # -1: 나머지로 계산
출력
[[ 0 1 2]
[ 3 4 5]
[ 6 7 8]
[ 9 10 11]]
[[ 0 4 8]
[ 1 5 9]
[ 2 6 10]
[ 3 7 11]]
False
(12,) (2, 6)

둘 다 (4, 3)이지만 내용이 다르다. reshape는 원소를 읽는 순서(행 우선)를 그대로 둔 채 다시 자르고, transpose(.T)는 축을 맞바꾼다. 이미지 축 순서를 바꿀 때 reshape를 쓰면 오류 없이 그림이 뒤섞인다(2-7절). reshape 전후의 전체 원소 수는 같아야 하고(12개를 (5, 3)으로는 못 자른다), -1은 한 축에만 쓸 수 있다.

뷰와 복사

섹션 제목: “뷰와 복사”
Y = np.arange(6).reshape(2, 3)
row = Y[0]
row[0] = 100
print(Y) # 슬라이스는 뷰: 원본도 바뀐다
safe = Y[1].copy()
safe[0] = -1
print(Y) # copy()는 따로 복사
출력
[[100 1 2]
[ 3 4 5]]
[[100 1 2]
[ 3 4 5]]

슬라이스는 원본 메모리를 함께 쓰는 뷰(view)다. 원본을 지켜야 하면 .copy()를 쓴다. 불리언 마스크·정수 리스트 인덱싱은 항상 복사본을 만든다.

2-5. 브로드캐스팅

섹션 제목: “2-5. 브로드캐스팅”

모양이 다른 두 배열을 계산할 때 NumPy는 아래 규칙으로 맞춘다.

  1. 두 shape를 뒤쪽 축부터 짝지어 본다. 축 수가 적은 쪽은 앞에 길이 1인 축이 있다고 본다.
  2. 짝지은 축마다 길이가 같거나, 한쪽이 1이면 된다. 아니면 오류다.
  3. 길이 1인 축은 상대 길이만큼 늘어난 것처럼 계산한다(실제로 복사하지는 않는다).
왼쪽 오른쪽 결과
(3, 4) (4,) (3, 4): 행마다 같은 벡터를 더함
(3, 4) (3, 1) (3, 4): 열마다 같은 벡터를 더함
(3, 4) (3,) 오류: 뒤쪽 축 4와 3
(3, 1) (1, 4) (3, 4): 양쪽 다 늘어남
(2, 1, 5) (3, 1) (2, 3, 5)

열별 표준화: (N, d)와 (d,)

섹션 제목: “열별 표준화: (N, d)와 (d,)”

특성마다 단위가 다르면(키 cm와 연봉 원) 열마다 평균을 빼고 표준편차로 나눠 크기를 맞춘다. 이것을 표준화(standardization)라 한다(학습에 주는 영향은 4장).

X = np.array([[1., 200.], [2., 300.], [3., 400.]]) # 표본 3개, 특성 2개
mean, std = X.mean(axis=0), X.std(axis=0)
print(mean, std, mean.shape)
Z = (X - mean) / std # (3, 2)와 (2,) → 열마다 같은 값을 쓴다
print(Z.round(3))
print(Z.mean(axis=0).round(3), Z.std(axis=0).round(3))
출력
[ 2. 300.] [ 0.81649658 81.64965809] (2,)
[[-1.225 -1.225]
[ 0. 0. ]
[ 1.225 1.225]]
[0. 0.] [1. 1.]

값이 모두 같은 열은 표준편차가 0이라 그대로 나누면 nan이 된다. sklearn의 StandardScaler는 이런 열의 나누는 값을 1로 두어 평균을 뺀 0을 그대로 남긴다.

행별 비율: keepdims가 필요한 경우

섹션 제목: “행별 비율: keepdims가 필요한 경우”

행마다 합이 1이 되게 나누려면 행 합 (N,)을 (N, 1)로 만들어야 한다. 개수처럼 음수가 없는 값에서 쓰는 계산이고, 행 합이 0인 행은 나눌 수 없으므로(nan) 따로 처리한다.

counts = np.array([[2, 1, 1], [0, 3, 1]]) # (2, 3)
try:
counts / counts.sum(axis=1) # (2, 3)과 (2,): 뒤쪽 축 3과 2
except ValueError as e:
print("오류:", e)
print(counts / counts.sum(axis=1, keepdims=True)) # (2, 3)과 (2, 1)
출력
오류: operands could not be broadcast together with shapes (2,3) (2,)
[[0.5 0.25 0.25]
[0. 0.75 0.25]]

더 위험한 것은 정사각 행렬이다. 축 길이가 우연히 같으면 오류 없이 틀린 답이 나온다.

sq = np.array([[1., 3.], [2., 6.]]) # 행 합 4, 8
wrong = sq / sq.sum(axis=1) # 오류 없음. [4, 8]이 열마다 나누는 값으로 쓰였다
right = sq / sq.sum(axis=1, keepdims=True) # (2, 1): 행마다 자기 합으로 나눔
print(wrong, "행 합", wrong.sum(axis=1))
print(right, "행 합", right.sum(axis=1))
출력
[[0.25 0.375]
[0.5 0.75 ]] 행 합 [0.625 1.25 ]
[[0.25 0.75]
[0.25 0.75]] 행 합 [1. 1.]

계산 뒤에는 “행 합이 정말 1인가”처럼 결과의 성질을 한 줄로 확인한다.

거리 행렬: 새 축을 넣어 모든 쌍 계산

섹션 제목: “거리 행렬: 새 축을 넣어 모든 쌍 계산”

None(= np.newaxis)을 인덱스에 넣으면 그 자리에 길이 1인 축이 생긴다. 질의 점 Q (m, d)와 데이터 점 P (n, d)의 모든 쌍 거리를 루프 없이 구한다.

P = np.array([[0., 0.], [3., 4.], [1., 1.]]) # 데이터 점 3개 (n=3, d=2)
Q = np.array([[0., 1.], [3., 3.]]) # 질의 점 2개 (m=2)
diff = Q[:, None, :] - P[None, :, :] # (2, 1, 2) - (1, 3, 2) → (2, 3, 2)
D = np.sqrt((diff ** 2).sum(axis=-1)) # 마지막 축(좌표)을 합침 → (2, 3)
print(diff.shape, D.shape)
print(D.round(3))
print(D.argmin(axis=1)) # 질의마다 가장 가까운 점의 번호
출력
(2, 3, 2) (2, 3)
[[1. 4.243 1. ]
[4.243 1. 2.828]]
[0 1]

D[i, j]는 질의 i와 점 j의 거리다. 첫 질의는 점 0과 점 2까지 거리가 똑같이 1인데, argmin은 최솟값이 여럿이면 먼저 나온 번호(0)를 돌려준다. 이것이 k-최근접 이웃(kNN, 8장)의 핵심 계산이다. 중간 배열 diff는 m×n×d개 원소를 담으므로, m·n이 크면 메모리가 부족해진다. 그때는 질의를 몇 묶음으로 나눠 계산한다.

2-6. 벡터화와 행렬곱

섹션 제목: “2-6. 벡터화와 행렬곱”

루프 vs 벡터화

섹션 제목: “루프 vs 벡터화”

같은 계산을 원소마다 파이썬 루프로 돌리는 것과, 배열 연산 한 번으로 하는 것을 비교한다.

import time
data = np.random.default_rng(0).normal(size=1_000_000)
t0 = time.perf_counter()
total = 0.0
for v in data:
total += v * v
t_loop = time.perf_counter() - t0
t0 = time.perf_counter()
total_vec = (data * data).sum()
t_vec = time.perf_counter() - t0
print(f"루프 {t_loop:.3f}초, 벡터화 {t_vec:.4f}초, 약 {t_loop / t_vec:.0f}배")
출력 (실행마다 다름)
루프 0.217초, 벡터화 0.0026초, 약 83배
print(np.isclose(total, total_vec)) # 결과는 같다(부동소수점 오차 범위)
출력
True

벡터화된 연산은 반복을 C로 작성된 NumPy 내부에서 처리한다. 숫자는 PC마다 다르지만 이 PC에서는 수십 배 이상 차이가 났다. 원소 수와 반복 횟수가 커질수록(학습은 같은 계산을 수천 번 반복한다) 이 차이가 누적된다.

수학 상자: 벡터·행렬·내적·노름

섹션 제목: “수학 상자: 벡터·행렬·내적·노름”
개념 식 NumPy 어디에 쓰나
벡터 숫자 d개를 나열한 것, 표본 하나 = 특성 벡터 shape (d,) 표본, 가중치, 임베딩
내적(dot product) a⋅b=a1b1+⋯+adbda \cdot b = a_1 b_1 + \dots + a_d b_d a @ b 선형 모델의 예측(4·6장)
노름(norm, 길이) ∥a∥=a⋅a\lVert a \rVert = \sqrt{a \cdot a} np.linalg.norm(a) 거리, 정규화(6장)
코사인 유사도 a⋅b∥a∥ ∥b∥\dfrac{a \cdot b}{\lVert a \rVert \, \lVert b \rVert}, −1~1 (두 벡터 모두 영벡터가 아닐 때) 정규화 후 내적 임베딩 검색(17장)
행렬곱 (m,k)(m, k) @ (k,n)(k, n) → (m,n)(m, n), 결과 [i,j][i, j] = A의 ii행과 B의 jj열의 내적 A @ B 신경망 층(10장), 어텐션(14장)
a = np.array([1., 2., 2.])
b = np.array([2., 0., 1.])
print(a @ b, np.linalg.norm(a), np.sqrt(a @ a))
print(round((a @ b) / (np.linalg.norm(a) * np.linalg.norm(b)), 3))
출력
4.0 3.0 3.0
0.596

선형 모델의 예측은 행렬곱 한 번에 절편을 더한 것이다. 표본 N개의 특성 X (N, d)와 가중치 w (d,)를 곱하면 표본마다 가중합 하나가 나오고, 여기에 모든 표본에 공통인 절편 b를 더한다(4장).

X = np.array([[1., 2.], [3., 4.], [5., 6.]]) # (3, 2): 표본 3개, 특성 2개
w = np.array([0.5, -1.0]) # (2,)
b = 2.0
print(X @ w + b) # (3, 2) @ (2,) → (3,)
W = np.array([[1., 0., -1.], [0., 1., 1.]]) # (2, 3): 출력 3개짜리 층
print((X @ W).shape) # (3, 2) @ (2, 3) → (3, 3)
출력
[ 0.5 -0.5 -1.5]
(3, 3)

행렬곱은 안쪽 두 길이가 같아야 한다((3, 2) @ (2, 3)의 2). 결과 shape는 바깥쪽 두 길이다. 이것은 두 입력이 모두 2차원일 때의 규칙이다. 1차원 벡터끼리 (d,) @ (d,)는 내적 숫자 하나, (N, d) @ (d,)는 행마다 내적한 (N,)이다.

코사인 유사도 검색: 각 행을 자기 노름으로 나눠 길이를 1로 맞춘 뒤 행렬곱 한 번이면 모든 쌍의 유사도가 나온다. 코사인 유사도는 두 벡터가 모두 영벡터가 아닐 때만 정의된다. 영벡터 행은 노름이 0이라 나누면 nan이 되므로 미리 빼거나 유사도를 0으로 둔다.

docs = np.array([[1., 0., 1.], [0., 2., 0.], [1., 1., 1.]]) # 문서 벡터 3개
query = np.array([[2., 0., 2.]]) # 질의 1개
dn = docs / np.linalg.norm(docs, axis=1, keepdims=True)
qn = query / np.linalg.norm(query, axis=1, keepdims=True)
sim = qn @ dn.T # (1, 3) @ (3, 3) → (1, 3)
print(sim.round(3))
print(np.argsort(-sim[0])) # 유사도 높은 순 문서 번호
출력
[[1. 0. 0.816]]
[0 2 1]

질의는 문서 0과 방향이 같아 유사도 1이다. 길이(크기)는 달라도 방향이 같으면 1이 된다. 이것이 거리 대신 코사인을 쓰는 이유다(17장).

2-7. 표·이미지·텍스트가 배열이 되는 방식

섹션 제목: “2-7. 표·이미지·텍스트가 배열이 되는 방식”
표는 (표본, 특성), 이미지는 (높이, 너비, 채널), 텍스트는 정수 ID를 담은 (문장 수, 길이) 배열이 된다표는 (표본, 특성), 이미지는 (높이, 너비, 채널), 텍스트는 정수 ID를 담은 (문장 수, 길이) 배열이 된다

그림 설명. 세 칸이 나란히 있다. 표는 행이 표본(꽃 한 송이), 열이 특성(꽃받침·꽃잎 길이·너비)인 (N, d) 배열이다. 이미지는 높이 H × 너비 W 격자가 빨강·초록·파랑 세 장 겹친 (H, W, C) 배열로, 픽셀마다 0~255 값이 있고 PyTorch는 채널 축을 앞으로 옮긴 (C, H, W)를 쓴다. 텍스트는 “나는 사과 를 먹었다”, “사과 를 샀다”가 어휘 사전으로 정수 ID [1, 5, 2, 3], [5, 2, 6, 0]이 된 (N, L) 배열이고, 짧은 문장 끝의 0은 패딩이다. 이 ID를 원-핫·단어 주머니·임베딩으로 바꿔 모델에 넣는다.

표: (표본 수, 특성 수)

섹션 제목: “표: (표본 수, 특성 수)”
from sklearn.datasets import load_iris, load_digits
iris = load_iris()
print(iris.data.shape, iris.data.dtype)
print(iris.data[:2])
출력
(150, 4) float64
[[5.1 3.5 1.4 0.2]
[4.9 3. 1.4 0.2]]

행이 표본, 열이 특성이다. sklearn 모델은 이 2차원 모양을 받는다. 표본 하나만 예측할 때도 x.reshape(1, -1)로 (1, 특성 수)를 만들어 넣는다. 이 자료에서 쓰는 대부분의 모델에는 문자열 범주(도시 이름 등)를 숫자로 바꿔 넣는다(03장). 범주형 열을 직접 받는 모델도 일부 있다.

이미지: 흑백 (H, W), 컬러 (H, W, C)

섹션 제목: “이미지: 흑백 (H, W), 컬러 (H, W, C)”

흑백 이미지는 높이 H × 너비 W 격자에 밝기를 담은 2차원 배열이다. 1장에서 본 손글씨 숫자가 그렇다.

digits = load_digits()
print(digits.images.shape, digits.images.dtype, digits.images.min(), digits.images.max())
flat = digits.images.reshape(len(digits.images), -1) # (N, 8, 8) → (N, 64)
print(flat.shape, np.array_equal(flat, digits.data))
출력
(1797, 8, 8) float64 0.0 16.0
(1797, 64) True

(N, 8, 8)을 (N, 64)로 펴면 픽셀 하나가 특성 하나인 표가 된다. 1장의 로지스틱 회귀가 이렇게 받은 입력이다. 편 배열도 너비를 알면 원래 위치로 되돌릴 수 있지만, 이 표를 받는 선형 모델은 “어느 픽셀이 위아래로 이웃인가”를 따로 쓰지 않는다. 이웃 관계를 구조로 쓰는 모델은 12장 CNN이다.

컬러 이미지는 픽셀마다 빨강·초록·파랑(RGB) 세 값이 있어 채널(channel) 축 C가 하나 더 생긴다. 축을 놓는 순서는 라이브러리마다 다르다.

쓰는 곳 한 장 묶음(배치) 값
Pillow RGB 이미지 → np.asarray (H, W, C) (N, H, W, C) uint8 0~255
PyTorch 모델 입력 (torchvision ToTensor에 uint8 (H, W, C)를 넣은 결과) (C, H, W) (N, C, H, W) float32 0~1

같은 (H, W, C)라도 읽는 방법마다 dtype·값 범위가 다르다. 예를 들어 matplotlib imread는 PNG를 float32 0~1로 읽는다. 그래서 읽은 직후 shape·dtype·min()·max()를 출력해 확인한다.

img = np.zeros((4, 6, 3), dtype=np.uint8) # 높이 4, 너비 6, 채널 3(RGB)
img[:, :3, 0] = 255 # 왼쪽 절반: 빨강 채널 최대
img[:, 3:, 2] = 255 # 오른쪽 절반: 파랑 채널 최대
print(img.shape, img[0, 0], img[0, 5]) # 픽셀 하나 = [R, G, B]
chw = img.transpose(2, 0, 1) # (H, W, C) → (C, H, W)
print(chw.shape)
print(chw[0]) # 빨강 채널 한 장
print(np.array_equal(img.reshape(3, 4, 6)[0], chw[0])) # reshape로는 채널이 분리되지 않는다
batch = np.stack([img, img[:, ::-1]]) # 원본과 좌우 뒤집은 것 2장 → 새 축
print(batch.shape)
출력
(4, 6, 3) [255 0 0] [ 0 0 255]
(3, 4, 6)
[[255 255 255 0 0 0]
[255 255 255 0 0 0]
[255 255 255 0 0 0]
[255 255 255 0 0 0]]
False
(2, 4, 6, 3)

transpose(2, 0, 1)은 “새 축 0 = 옛 축 2(C), 새 축 1 = 옛 축 0(H), 새 축 2 = 옛 축 1(W)“이다. np.stack은 같은 모양 배열들을 새 축으로 쌓아 배치를 만든다(이미 있는 축으로 이어 붙이는 것은 np.concatenate).

텍스트: 단어 → 정수 ID → 배열

섹션 제목: “텍스트: 단어 → 정수 ID → 배열”

글은 먼저 단위(여기서는 띄어쓰기로 나눈 단어, 16장에서는 토큰)로 자르고, 어휘 사전(vocabulary)으로 각 단어에 정수 ID를 준다. 문장마다 길이가 다르므로 짧은 문장 뒤를 패딩(padding) ID로 채워 (N, L) 배열을 만든다.

sentences = ["나는 사과 를 먹었다", "나는 바나나 를 샀다", "사과 를 샀다"]
vocab = sorted({w for s in sentences for w in s.split()})
word_to_id = {w: i + 1 for i, w in enumerate(vocab)} # 0은 패딩용으로 비워 둔다
print(word_to_id)
ids = [[word_to_id[w] for w in s.split()] for s in sentences]
L = max(len(seq) for seq in ids)
padded = np.zeros((len(ids), L), dtype=np.int64)
for i, seq in enumerate(ids):
padded[i, :len(seq)] = seq
print(padded)
출력
{'나는': 1, '를': 2, '먹었다': 3, '바나나': 4, '사과': 5, '샀다': 6}
[[1 5 2 3]
[1 4 2 6]
[5 2 6 0]]

정수 ID는 이름표일 뿐 크기에 뜻이 없다(ID 5인 “사과”가 ID 2인 “를”보다 큰 것이 아니다). 그래서 모델에 넣을 때는 두 가지 방법을 쓴다.

V = len(vocab) + 1 # 패딩 0 포함
onehot = np.eye(V, dtype=int)[padded] # (3, 4) 정수 배열로 행을 고름 → (3, 4, 7)
print(onehot.shape)
print(onehot[2]) # 세 번째 문장: 마지막 줄은 패딩(ID 0)
bow = onehot.sum(axis=1) # 단어 축을 합침 → (3, 7)
bow[:, 0] = 0 # 패딩 개수는 지운다
print(bow)
출력
(3, 4, 7)
[[0 0 0 0 0 1 0]
[0 0 1 0 0 0 0]
[0 0 0 0 0 0 1]
[1 0 0 0 0 0 0]]
[[0 1 1 1 0 1 0]
[0 1 1 0 1 0 1]
[0 0 1 0 0 1 1]]

이 방법은 작은 어휘에서 원리를 보기 위한 것이다. 어휘가 5만 개면 np.eye(V)만으로 약 20GB(int64)이므로, 실제로는 단어 개수를 바로 세거나 0이 대부분인 표를 압축해 담는 희소 행렬을 쓴다. 단어 주머니는 순서를 버린다. 순서만 다른 두 문장은 같은 벡터가 된다.

a = "철수 가 영희 를 도왔다".split()
b = "영희 가 철수 를 도왔다".split()
print(sorted(a) == sorted(b)) # 단어 개수가 같으면 단어 주머니도 같다
출력
True

주제 분류처럼 “어떤 단어가 나왔나”가 중요한 과제에는 단어 주머니 + 고전 머신러닝이 빠르고 쓸 만한 기준선이다. 누가 누구를 도왔는지처럼 순서가 뜻을 바꾸는 과제에는 순서를 다루는 모델(13장 RNN, 14장 트랜스포머)과 단어마다 학습된 벡터인 임베딩(13·17장)을 쓴다.

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

섹션 제목: “2-8. 선택 기준표에 추가”
상황 고를 것 이유 장
표 데이터를 모델에 넣는다 (표본 수, 특성 수) 2차원 숫자 배열 sklearn 모델이 받는 모양. 표본 하나도 (1, 특성 수). 문자열 범주는 숫자로 바꾼다(03장) 02
이미지를 모델에 넣는다 라이브러리가 기대하는 축 순서·dtype·값 범위부터 확인 Pillow RGB 이미지를 np.asarray로 바꾸면 (H, W, 3) uint8 0~255, PyTorch는 (N, C, H, W) float. 축 순서는 transpose로 바꾼다(reshape 아님) 02
글을 분류하는데 단어 순서는 크게 중요하지 않다 단어 주머니(단어 개수 벡터) + 고전 머신러닝 만들기 쉽고 빠른 기준선. 순서가 뜻을 바꾸면 시퀀스 모델·임베딩(13~17장) 02
표본마다 같은 계산을 반복한다 파이썬 루프 대신 벡터화(브로드캐스팅·행렬곱) 훨씬 빠르고 코드가 짧다. 중간 배열이 너무 크면 묶음으로 나눠 계산 02

확인 문제

섹션 제목: “확인 문제”

2-9. 실습과 문제

섹션 제목: “2-9. 실습과 문제”

실습/문제/ch02_데이터를_숫자로_NumPy.ipynb를 .venv 커널로 열고 위에서부터 푼다. 내려받기가 없고 CPU로 1분 안에 끝난다. 다 푼 뒤 해설 노트북과 비교한다.

번호 유형 내용
1 개념 집계·인덱싱·reshape 결과 shape 예측
2 개념 브로드캐스팅 가능 여부 판단
3 코드 열별 표준화(sklearn StandardScaler와 비교)
4 코드 행별 비율(keepdims)
5 코드 브로드캐스팅으로 최근접 점 찾기 → 붓꽃 1-최근접 이웃 분류
6 코드 코사인 유사도 행렬 → 손글씨 숫자 유사 이미지 검색
7 코드 이미지 배치를 모델 입력 (N, C, H, W) float로 변환
8 코드 패딩된 ID 배열에서 단어 주머니 만들기
9 사례 오류 없이 엉뚱한 예측을 내는 이미지 전처리 진단
10 사례 단어 주머니로 충분한 과제와 순서가 필요한 과제

2-10. 공식 문서와 참고 자료

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