콘텐츠로 이동
교육자료

AI 기초 › 02장

데이터를 숫자로: NumPy

읽기 1시간 30분 · 실습 1시간 30분인쇄용 보기(PDF)

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

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

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

  • scikit-learn 모델은 NumPy 배열을 입력으로 받고 배열을 돌려준다.
  • PyTorch의 텐서(10장)는 shape·축·브로드캐스팅 규칙이 NumPy와 거의 같다. 이 장의 규칙은 딥러닝·LLM 장까지 그대로 쓰인다.
  • 모델이 틀린 답을 낼 때 원인이 모양인 경우가 많다. 축을 잘못 골라도 오류 없이 엉뚱한 숫자가 나오기 때문이다. 이 장에서 “실행 전에 shape를 예측하고, 실행 후 확인하는” 습관을 들인다.

파이썬 리스트와 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]

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

용어 뜻 확인
배열(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]]
  • np.zeros(shape): 0으로 채운 배열(기본 dtype float64).
  • np.arange(시작, 끝, 간격): 파이썬 range처럼 끝값은 빼고 간격만큼 증가.
  • np.linspace(시작, 끝, 개수): 끝값을 포함해 같은 간격으로 개수개.
  • rng.normal(size=...): 평균 0, 표준편차 1인 정규분포에서 뽑은 난수. 시드(default_rng(0)의 0)가 같으면 매번 같은 수가 나온다.

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

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)로 바꾼다.

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이라도 축에 따라 뜻이 전혀 다르다.

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()를 쓴다. 불리언 마스크·정수 리스트 인덱싱은 항상 복사본을 만든다.

모양이 다른 두 배열을 계산할 때 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)

특성마다 단위가 다르면(키 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이 크면 메모리가 부족해진다. 그때는 질의를 몇 묶음으로 나눠 계산한다.

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

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인 “를”보다 큰 것이 아니다). 그래서 모델에 넣을 때는 두 가지 방법을 쓴다.

  • 원-핫(one-hot): 길이 V(어휘 수)짜리 0 벡터에서 ID 위치만 1. 대각선만 1이고 나머지가 0인 단위행렬 np.eye(V)의 행을 ID로 고르면 된다. ID 하나가 길이 V인 행 하나로 바뀌므로 (N, L) ID 배열은 (N, L, V)가 된다.
  • 단어 주머니(bag of words): 문장의 원-핫을 모두 더한 단어 개수 벡터. 문장 하나가 (V,), 묶음이 (N, V) 표가 된다.
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차원 숫자 배열 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

11문항. 풀면 결과가 기록되고 복습 일정에 들어간다.

문제 1 · 빈칸

np.arange(2, 20, 5)의 마지막 원소는 ____이다.

정답과 해설

정답: 17

2에서 시작해 5씩 늘리면 2, 7, 12, 17이고, 다음 값 22는 끝값 20을 넘으므로 들어가지 않는다. arange는 파이썬 range처럼 끝값을 빼고 만든다.

문제 2 · 결과 예측

아래 코드의 출력은?

import numpy as np
X = np.arange(12).reshape(3, 4)
print(X[:, 2].shape, X[:, [2]].shape, X[1:, 2:].shape)
보기
정답과 해설

정답: 1번

정수 하나로 고른 축은 사라지므로 X[:, 2]는 (3,)이다. 리스트 [2]로 고르면 축이 남아 (3, 1)이다. X[1:, 2:]는 행 1~2, 열 2~3을 남겨 (2, 2)다.

오답 해설: (3, 1)로 시작하는 답은 정수 인덱싱도 축을 남긴다고 본 것이다. 둘째가 (3,)인 답은 리스트 인덱싱도 축을 없앤다고 본 것이다. (1, 2)는 1:을 한 행만 고르는 것으로 본 답이다.

문제 3 · 객관식

X = np.arange(24).reshape(4, 6)일 때 X.reshape(6, 4)와 X.T를 비교한 설명으로 옳은 것은?

보기
정답과 해설

정답: 4번

reshape는 원소를 읽는 순서(행 우선)를 그대로 둔 채 (6, 4)로 다시 자르고, .T는 축을 맞바꾼다. 그래서 shape는 같아도 X.T[0]은 X의 첫 열 [0, 6, 12, 18]이고 X.reshape(6, 4)[0]은 첫 행의 앞 네 원소 [0, 1, 2, 3]이다.

오답 해설: X.reshape(6, 4)[0]은 [0, 1, 2, 3], X.T[0]은 [0, 6, 12, 18]이라 np.array_equal은 False다. 두 결과의 shape는 모두 (6, 4)다. 행 우선으로 다시 자르는 것은 reshape만의 동작이다.

문제 4 · 객관식

shape (5, 1, 4)인 배열과 (3, 1)인 배열을 더한 결과의 shape는?

보기
정답과 해설

정답: 3번

축 수가 적은 (3, 1)을 앞에 1을 붙여 (1, 3, 1)로 보고 뒤쪽부터 짝짓는다. 4와 1 → 4, 1과 3 → 3, 5와 1 → 5이므로 (5, 3, 4)다.

오답 해설: (5, 1, 4)는 길이 1인 축이 늘어나는 것을 빠뜨린 답이다. (3, 5, 4)는 앞쪽 축부터 맞춘 답이다. 모든 짝이 같거나 한쪽이 1이므로 오류가 나지 않는다.

문제 5 · O/X

행마다 합이 1이 되게 하려고 M / M.sum(axis=1)을 썼다. 오류가 나지 않았다면 결과는 맞다.

보기
정답과 해설

정답: X (거짓)

M이 정사각 행렬이면 행 합 (N,)이 열 쪽에 맞춰 붙어도 축 길이가 같아 오류가 나지 않고, 열마다 다른 행의 합으로 나눈 틀린 결과가 나온다. keepdims=True로 (N, 1)을 만들어 나누고, 계산 뒤 .sum(axis=1)이 1인지 확인한다.

문제 6 · 객관식

질의 점 Q (1000, 64)와 데이터 점 P (5000, 64)의 모든 쌍 거리를 구하려고, 먼저 diff = Q[:, None, :] - P[None, :, :]로 좌표 차이를 만든다. 중간 배열 diff의 원소 수는?

보기
정답과 해설

정답: 2번

(1000, 1, 64) - (1, 5000, 64)는 (1000, 5000, 64)가 되어 3억 2천만 개 원소다. float64면 약 2.56GB다. 이렇게 크면 질의를 몇 묶음으로 나눠 계산한다.

오답 해설: 1000 × 5000은 좌표 축을 합친 뒤의 거리 행렬 D의 원소 수다. 1000 × 64 + 5000 × 64는 입력 두 배열의 크기이고, 64는 좌표 하나의 길이다.

문제 7 · O/X

float64 난수 100만 개의 제곱합을 파이썬 for 루프로 구한 total과 (data * data).sum()으로 구한 total_vec이 같은지 확인할 때는, total == total_vec보다 np.isclose(total, total_vec)가 알맞다.

보기
정답과 해설

정답: O (참)

두 방법은 수를 더하는 순서가 달라 부동소수점 반올림 오차가 다르게 쌓이므로 마지막 자리가 다를 수 있다. 그래서 정확히 같은지(==)가 아니라 오차 범위 안에서 같은지(np.isclose)를 본다.

문제 8 · 결과 예측

아래 코드의 출력은?

import numpy as np
a = np.array([3., 4.])
print(np.linalg.norm(a), a @ a)
보기
정답과 해설

정답: 2번

노름은 a⋅a=9+16=5\sqrt{a \cdot a} = \sqrt{9 + 16} = 5이고, 자기 자신과의 내적 a @ a는 9+16=259 + 16 = 25다.

오답 해설: 25.0 5.0은 두 값을 바꿔 적은 답이다. 7.0은 원소를 그냥 더한 값으로, 노름도 내적도 아니다.

문제 9 · 객관식

Pillow로 읽은 RGB 이미지 묶음 batch가 shape (N, H, W, 3), dtype uint8(0~255)이다. PyTorch 모델 입력 형식 (N, C, H, W), float32 0~1로 바꾸는 코드는?

보기
정답과 해설

정답: 4번

채널 축을 앞으로 옮기는 것은 transpose(0, 3, 1, 2)이고, 값은 float32로 바꾼 뒤 255로 나눠 0~1로 만든다.

오답 해설: reshape는 축을 바꾸지 않고 원소를 다시 잘라 채널이 뒤섞인다(오류는 나지 않는다). astype만 하면 값 범위는 맞지만 축 순서가 (N, H, W, C) 그대로다. transpose만 하면 축은 맞지만 uint8 0~255 그대로다.

문제 10 · 객관식

뉴스 기사 1만 건을 스포츠·경제·정치로 분류하는 첫 기준선을 빨리 만들려고 한다. 어떤 단어가 나왔는지가 주로 중요하다. 선택 기준표에 따르면?

보기
정답과 해설

정답: 2번

단어 순서가 크게 중요하지 않은 글 분류에는 단어 주머니와 고전 머신러닝이 만들기 쉽고 빠른 기준선이다.

오답 해설: 정수 ID는 이름표일 뿐 크기에 뜻이 없어 숫자 특성으로 쓰면 안 된다. 시퀀스 모델은 순서가 뜻을 바꾸는 과제에 쓰는 것으로, 첫 기준선으로는 무겁다. 원-핫 (N, L, V)는 3차원이라 2차원 (표본 수, 특성 수)를 받는 sklearn 모델에 그대로 넣을 수 없다. 단어 축을 합치면 단어 주머니가 된다.

문제 11 · O/X

특성 4개로 학습한 sklearn 모델에 꽃 한 송이를 예측할 때는 shape (4,)인 배열을 그대로 넣는다.

보기
정답과 해설

정답: X (거짓)

sklearn 모델은 2차원 (표본 수, 특성 수)를 받으므로 표본 하나도 x.reshape(1, -1)로 (1, 4)를 만들어 넣는다. (4,)를 넣으면 오류가 난다.

실습/문제/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 사례 단어 주머니로 충분한 과제와 순서가 필요한 과제