P5-9.2 배치(batch)와 텐서(tensor) 계산¶

Section ID: P5-9.2 Version: v2026.07.20

P5-9.1에서는 딥러닝이 왜 GPU와 병렬 처리(parallel processing)에 잘 맞는지 보았습니다. 여기서 바로 다음 질문이 생깁니다.

그렇다면 GPU가 잘 처리하는 딥러닝 계산은 실제로 어떤 모양의 데이터 묶음으로 주어지는가?

이 질문에 답할 때 반복해서 등장하는 표현이 배치(batch)와 텐서(tensor)입니다.

배치(batch)는 여러 샘플을 한꺼번에 계산하기 위한 묶음이고, 텐서(tensor)는 그런 묶음을 포함해 딥러닝이 다루는 다차원 숫자 배열의 일반 이름이다.

shape와 계산 단위를 다시 짧게 복습해야 할 때는 개념사전의 배치(batch)와 텐서(tensor) 항목으로 돌아갑니다.

batch와 tensor가 계산을 묶는 질문¶

배치(batch)는 왜 필요한가?
텐서(tensor)는 벡터와 행렬에서 어떻게 확장되는가?
배치 단위 계산은 병렬 처리와 어떤 관계가 있는가?
입력 shape를 읽는 감각은 왜 중요한가?

이 절에서는 GPU가 잘 처리하는 계산이 실제로는 어떤 배치 묶음과 텐서 shape로 나타나는지 붙잡는 데 집중합니다. 즉, 여기서는 텐서 수학의 엄밀한 정의보다 딥러닝 계산이 어떤 데이터 모양으로 흐르는가를 먼저 닫습니다.

대신 이번 절에서 바로 더 넓히지 않을 질문도 분명합니다. shape가 왜 중요한가와 큰 행렬 계산이 어떻게 이어지는가라는 감각은 P5-13.2 attention과 P5-14.3, P5-14.4 Transformer 계산 구조에서 다시 회수합니다.

병렬 단위와 shape의 판단 기준¶

배치를 여러 샘플을 한 번에 처리하는 계산 단위로 설명할 수 있습니다.
텐서를 벡터와 행렬을 포함하는 다차원 배열로 설명할 수 있습니다.
shape를 읽는 습관이 왜 딥러닝 실습에 중요한지 말할 수 있습니다.
실행 가능한 Python 예제로 batch와 tensor shape 감각을 확인할 수 있습니다.

배치는 왜 필요한가¶

딥러닝에서는 같은 모델을 많은 샘플에 반복 적용합니다. 한 샘플씩 순서대로 처리할 수도 있지만, 그러면 병렬 처리의 이점을 충분히 살리기 어렵습니다.

배치(batch)는 여러 샘플을 묶어서 한 번에 계산하는 방식입니다.

예를 들어:

이미지 1장만 처리하는 대신 32장을 같이 처리하고
문장 1개만 넣는 대신 여러 문장을 같이 넣으며
표 데이터도 여러 행(row)을 한 번에 모델에 전달합니다

다음처럼 이해하면 충분합니다.

배치는 모델이 같은 연산을 여러 샘플에 반복해야 할 때, 그 반복을 한 덩어리로 묶어 계산하게 해 준다.

배치를 쓰면 무엇이 좋아지나¶

배치를 쓰는 이유는 단순히 편의 때문만이 아닙니다.

GPU의 병렬 계산을 더 잘 활용할 수 있고
샘플 하나씩 처리할 때보다 계산 효율이 좋아질 수 있으며
gradient도 여러 샘플의 정보를 한 번에 반영하게 됩니다

물론 배치가 너무 크면 메모리를 많이 쓰거나, 학습 dynamics가 달라질 수도 있습니다. 하지만 입문 단계에서는 먼저 병렬 계산의 기본 단위로 이해하면 충분합니다.

텐서는 무엇인가¶

Part 2에서 스칼라(scalar), 벡터(vector), 행렬(matrix)를 보았습니다. 텐서는 이 흐름의 자연스러운 확장입니다.

다음 표로 설명하면 충분합니다.

이름	예시	차원 수
스칼라(scalar)	`3.14`	0차원
벡터(vector)	`[1, 2, 3]`	1차원
행렬(matrix)	`[[1, 2], [3, 4]]`	2차원
텐서(tensor)	배치가 붙은 이미지/문장 배열	3차원 이상도 포함

즉, 텐서는 특별한 마법 개념이라기보다 다차원 숫자 배열을 넓게 부르는 이름입니다.

딥러닝에서는 입력, 중간 표현, 출력이 모두 텐서로 흐른다고 보면 된다.

이미지, 문장, 표 데이터는 어떤 텐서로 보이나¶

딥러닝에서는 데이터 종류가 달라도 결국 텐서 모양으로 정리됩니다.

예를 들어:

표 데이터: (batch_size, feature_count)
흑백 이미지: (batch_size, height, width)
컬러 이미지: (batch_size, channel, height, width) 또는 프레임워크에 따라 채널 위치가 다를 수 있음
문장 임베딩: (batch_size, sequence_length, embedding_dim)

즉, 텐서는 데이터 도메인을 넘어 공통 계산 언어 역할을 합니다.

shape를 읽는 감각이 왜 중요한가¶

실습에서 가장 자주 만나는 오류 중 하나는 shape를 잘못 읽어 어느 축이 배치인지, 어느 축이 길이·채널·특징 차원인지를 헷갈리는 것입니다.

예를 들어:

배치 차원을 빼먹거나
행과 열을 뒤집거나
채널 위치를 헷갈리거나
라벨 shape와 출력 shape가 맞지 않으면

모델이 아예 실행되지 않거나, 실행은 되지만 엉뚱한 계산을 할 수 있습니다.

다음 습관이 중요합니다.

딥러닝 실습에서는 값 자체만 보지 말고, 항상 shape를 함께 본다.

배치 계산과 병렬 처리의 연결¶

P5-9.1에서 본 GPU의 강점은 비슷한 연산을 많이 동시에 처리하는 데 있었습니다. 배치는 바로 그 구조를 딥러닝 계산에 맞게 제공하는 방식입니다.

즉:

모델은 같은 가중치를 유지한 채
배치 안의 여러 샘플에 대해
같은 forward와 backward 패턴을 반복합니다

이 반복이 batch dimension으로 묶이면서 병렬 계산과 자연스럽게 연결됩니다.

이를 아주 단순하게 그리면 다음과 같습니다.

flowchart TD
  A["샘플 1"]
  B["샘플 2"]
  C["샘플 3"]
  D["배치 텐서"]
  E["같은 모델 계산"]
  F["배치 출력"]

  A --> D
  B --> D
  C --> D
  D --> E
  E --> F

사례 및 예시¶

사례. 같은 배치축을 표, 이미지, 문장에 붙여 읽을 때¶

생산 배치 특징 표, 표면 검사 이미지, 정비 로그 임베딩을 한 번에 떠올려 보겠습니다. 사람은 처음에는 표는 표대로, 이미지는 사진대로, 문장은 글줄대로 읽기 때문에 세 입력이 서로 다른 종류라고 느끼기 쉽습니다. 하지만 딥러닝 계산에서는 셋 모두 배치축 + 그 뒤에 남는 구조라는 같은 틀로 먼저 읽습니다. 즉, (32, 20)은 32개 배치를 한꺼번에 처리하는 표 입력이고, (32, 3, 224, 224)은 32장 이미지를 한꺼번에 처리하는 입력이며, (16, 128, 768)은 16개 문서를 한꺼번에 처리하는 입력입니다.

여기서 사람이 먼저 쓰던 기준은 표는 행을 세고, 이미지는 사진 수를 세고, 문장은 길이를 센다는 쪽입니다. 하지만 이 기준만으로는 모델이 실제로 무엇을 동시에 처리하는지 놓치기 쉽습니다. shape 관점으로 다시 읽으면 먼저 고정해야 할 것은 항상 첫 축입니다. 첫 축은 동시에 모델에 들어가는 샘플 묶음, 즉 배치축이고, 그 뒤에 붙는 축이 feature인지, 채널과 공간인지, 토큰과 임베딩인지를 나누어 읽어야 합니다.

즉, 이 사례에서 먼저 확인해야 할 결과는 세 가지입니다.

첫 축이 항상 동시에 처리하는 샘플 수로 읽히는가
배치 하나를 꺼냈을 때 표는 feature, 이미지는 채널-공간, 문장은 토큰-임베딩 구조가 남는가
shape를 숫자 묶음이 아니라 축 역할로 읽어야 실습 오류를 줄일 수 있는가

이 사례를 먼저 고정해 두면, 아래 비교 표와 Python 예제에서 왜 계속 첫 축과 배치 하나를 꺼낸 뒤 남는 구조를 같이 보라고 하는지 더 자연스럽게 연결됩니다.

장면	사람이 먼저 보기 쉬운 결과	shape 관점에서 실제로 구분해야 할 것	바로 다음에 확인할 것
표 데이터 분류	표의 행을 한 줄씩 읽는 데이터처럼 보기 쉽습니다.	첫 축은 동시에 계산되는 배치 수이고, 나머지는 feature 축입니다.	`(32, 20)`에서 `32`와 `20`의 역할을 실제로 구분해 봅니다.
이미지 분류	사진 몇 장인지 정도만 먼저 세기 쉽습니다.	배치축, 채널축, 공간축을 나눠 읽어야 convolution과 pooling 의미가 맞게 보입니다.	`(32, 3, 224, 224)`에서 각 축이 무엇인지 말해 봅니다.
문장 모델	문장 길이만 보면 된다고 느끼기 쉽습니다.	배치축, 토큰축, 임베딩축을 함께 읽어야 attention과 sequence 계산으로 이어집니다.	`(batch, sequence_length, embedding_dim)`에서 각 축의 역할을 구분해 봅니다.

세 입력을 shape 기준으로 한눈에 놓으면 다음처럼 읽을 수 있습니다.

flowchart TD
  A["공통 질문: 첫 축은 무엇인가?"]

  subgraph TAB["표 데이터"]
    B["(batch, feature)"]
    C["배치 뒤에 feature 축"]
  end

  subgraph IMG["이미지"]
    D["(batch, channel, height, width)"]
    E["배치 뒤에 채널·공간축"]
  end

  subgraph TXT["문장"]
    F["(batch, sequence, embedding)"]
    G["배치 뒤에 토큰·임베딩축"]
  end

  A --> B --> C
  A --> D --> E
  A --> F --> G

이 비교 도식에서 먼저 고정해야 할 점은 다음과 같습니다.

세 경우 모두 첫 축은 동시에 처리하는 샘플 묶음, 즉 배치축입니다.
달라지는 것은 첫 축 뒤에 붙는 구조로, 표 데이터는 feature 축, 이미지는 채널·공간축, 문장은 토큰·임베딩축이 남습니다.
그래서 shape를 읽을 때는 숫자 개수보다 먼저 첫 축 뒤에 무엇이 남는가를 구분해야 실습 오류를 줄일 수 있습니다.

연습 및 예제¶

이번 예제의 목표는 같은 첫 번째 축이 생산 배치 표 데이터, 표면 검사 이미지, 정비 로그 임베딩에서 모두 배치축으로 읽힌다는 점을 직접 확인하는 것입니다.

입력:

생산 배치 특징 표
표면 검사 이미지 비슷한 4차원 텐서
정비 로그 임베딩 비슷한 3차원 텐서

출력:

각 텐서의 shape
첫 번째 축이 가리키는 배치 수
배치 하나를 꺼냈을 때 남는 구조
축을 잘못 읽었을 때 어떤 오해가 생기는지에 대한 비교

문제 상황:

표 데이터, 이미지, 문장 임베딩은 모두 텐서로 다룰 수 있지만 축의 의미가 서로 다르다
shape를 숫자 묶음으로만 보면 첫 축과 나머지 축의 역할을 섞어 읽기 쉽다

확인할 개념:

텐서 해석은 값 자체보다 shape와 축 의미를 먼저 읽는 데서 시작한다
배치 하나를 꺼냈을 때 어떤 구조가 남는지 보면 각 축 역할을 더 쉽게 구분할 수 있다
축을 잘못 읽으면 배치 수, 채널 수, 토큰 수를 서로 바꿔 오해할 수 있다

초심자 기준에서는 이 예제를 다음 세 단계로 읽는 편이 좋습니다.

읽는 단계	먼저 볼 것	바로 이어서 붙잡을 질문
1	각 텐서의 `shape[0]`	첫 축이 정말 배치 수로 읽히는가
2	배치 하나를 꺼냈을 때 남는 `shape`	표, 이미지, 문장에서 첫 축 뒤에 남는 구조가 어떻게 다른가
3	`[wrong reading check]`	같은 숫자라도 배치축과 채널축, 토큰축을 바꿔 읽으면 어떤 오해가 생기는가

입력(input):

위에 정리한 생산 배치 특징 표, 표면 검사 이미지 텐서, 정비 로그 임베딩 형태 텐서를 사용합니다.

코드를 보기 전에 먼저 각 텐서에서 첫 축과 배치 하나를 꺼낸 뒤 남는 축이 무엇을 뜻할지 예상해 보면 좋습니다.

텐서	먼저 예상해 볼 비교	예상 이유
`tabular_batch`	첫 축은 생산 배치 수, 배치 하나를 꺼내면 feature 벡터가 남을 가능성	표 데이터는 `(batch, feature)` 구조로 읽기 때문입니다.
`image_batch`	첫 축은 이미지 수, 배치 하나를 꺼내면 `(channel, height, width)`가 남을 가능성	이미지는 배치 밖에 채널과 공간축이 따로 있기 때문입니다.
`text_batch`	첫 축은 정비 로그 문서 수, 배치 하나를 꺼내면 `(sequence_length, embedding_dim)`이 남을 가능성	문장 텐서는 토큰축과 임베딩축을 함께 갖기 때문입니다.

여기서 실제로 확인해야 할 차이도 단순 shape 암기에서 끝나지 않습니다. 첫 축을 배치 수로 제대로 읽지 못하면 이미지 수와 채널 수를 바꿔 세거나, 문서 수와 토큰 길이를 바꿔 세게 됩니다. 즉, 이 절의 핵심은 숫자 맞히기가 아니라 모델에 몇 개 샘플을 넣는가, 한 샘플 안에 어떤 구조가 남는가를 실습 판단으로 연결하는 데 있습니다.

이 표의 목적은 첫 축이 무엇인지와 배치 하나를 꺼낸 뒤 무엇이 남는지를 분리해서 읽는 것입니다.

# 표, 이미지, 텍스트 텐서에서 첫 축이 batch이고 샘플 하나를 꺼내면 어떤 축 구조가 남는지 확인하는 예제입니다.
import numpy as np

tabular_batch = np.array([
    [12, 180, 1],
    [4, 95, 0],
    [9, 140, 1],
])

# (batch, channel, height, width)
image_batch = np.arange(2 * 3 * 2 * 2).reshape(2, 3, 2, 2)

# (batch, sequence_length, embedding_dim)
text_batch = np.arange(2 * 4 * 3).reshape(2, 4, 3)

print("tabular_batch shape =", tabular_batch.shape)
print("number of production batches =", tabular_batch.shape[0])
print("one batch feature row =", tabular_batch[0].tolist())
print()

print("image_batch shape =", image_batch.shape)
print("number of images =", image_batch.shape[0])
print("first image shape =", image_batch[0].shape)
print("first image, first channel =")
print(image_batch[0, 0])
print()

print("text_batch shape =", text_batch.shape)
print("number of maintenance logs =", text_batch.shape[0])
print("first log embedding shape =", text_batch[0].shape)
print("first token embedding =", text_batch[0, 0].tolist())
print()

print("[wrong reading check]")
print("if image_batch.shape[1] is read as number of images ->", image_batch.shape[1])
print("actual number of images ->", image_batch.shape[0])
print("if text_batch.shape[1] is read as number of logs ->", text_batch.shape[1])
print("actual number of logs ->", text_batch.shape[0])

출력에서는 각 batch의 shape와 첫 샘플 구조가 데이터 종류마다 어떻게 달라지는지부터 보면 됩니다.

tabular_batch shape = (3, 3)
number of production batches = 3
one batch feature row = [12, 180, 1]

image_batch shape = (2, 3, 2, 2)
number of images = 2
first image shape = (3, 2, 2)
first image, first channel =
[[0 1]
 [2 3]]

text_batch shape = (2, 4, 3)
number of maintenance logs = 2
first log embedding shape = (4, 3)
first token embedding = [0, 1, 2]

[wrong reading check]
if image_batch.shape[1] is read as number of images -> 3
actual number of images -> 2
if text_batch.shape[1] is read as number of logs -> 4
actual number of logs -> 2

세 경우 모두 첫 번째 축은 동시에 처리하는 배치 수입니다
배치 하나를 꺼내면 표는 feature 행, 이미지는 채널-공간 구조, 문장은 토큰-임베딩 구조가 남습니다
shape를 읽는다는 것은 숫자 개수만 세는 일이 아니라 각 축이 무엇을 뜻하는지 해석하는 일입니다

텐서	지금 읽어야 할 핵심
`tabular_batch`	첫 축을 생산 배치 수로 읽고, 배치 하나를 꺼내면 feature 벡터가 남습니다.
`image_batch`	첫 축은 이미지 수이고, 두 번째 축 `3`은 이미지 수가 아니라 채널 수입니다.
`text_batch`	첫 축은 정비 로그 수이고, 두 번째 축 `4`는 로그 수가 아니라 토큰 길이입니다.

출력 숫자를 읽을 때도 배열 크기와 축 의미를 분리해서 봐야 합니다.

비교	출력에서 먼저 보이는 것	숫자만 보면 남기 쉬운 해석	shape 관점까지 보면 바뀌는 해석
`tabular_batch shape = (3, 3)`	두 숫자가 같아서 같은 역할처럼 보일 수 있습니다.	둘 다 그냥 `3개`이니 큰 차이 없다고 보기 쉽습니다.	앞의 `3`은 생산 배치 수이고, 뒤의 `3`은 각 배치의 feature 수라 역할이 완전히 다릅니다.
`image_batch shape = (2, 3, 2, 2)`	`3`이 눈에 띄어 이미지 수처럼 오해하기 쉽습니다.	두 번째 축도 샘플 수 비슷한 것으로 보기 쉽습니다.	실제 이미지 수는 첫 축 `2`이고, 두 번째 축 `3`은 채널 수이므로 축을 바꾸어 읽으면 계산 의미가 틀어집니다.
`text_batch shape = (2, 4, 3)`	`4`가 커 보여 문서 수처럼 오해하기 쉽습니다.	가운데 숫자를 로그 개수처럼 읽고 넘어가기 쉽습니다.	첫 축 `2`가 로그 수이고, `4`는 토큰 길이, `3`은 임베딩 차원이라 attention 입력 해석의 기준이 됩니다.

실습 판단 기준	축을 잘못 읽으면 생기기 쉬운 오해	shape 관점까지 읽고 바뀌는 판단
표 데이터 입력 설정	`(3, 3)`이면 아무 축이나 바꿔도 비슷하다고 느끼기 쉽다	첫 축이 배치 수이므로, feature 축을 잘못 두면 한 step에 몇 개 샘플이 들어가는지부터 틀어질 수 있다고 먼저 본다
이미지 모델 입력 점검	`3`을 이미지 수처럼 읽고 배치를 3장으로 오해하기 쉽다	실제 배치는 2장이고 `3`은 채널 수이므로, 채널축과 배치축을 바꿔 넣으면 convolution 해석 자체가 틀어진다고 본다
텍스트 모델 입력 점검	`4`를 로그 수처럼 읽고 한 번에 4문서를 넣는다고 오해하기 쉽다	실제로는 2개 문서를 넣고 각 문서를 4토큰 길이로 잘랐다고 읽어야 하므로, 토큰축과 배치축을 구분해 padding·attention 입력을 점검하게 된다

즉, shape 해석에서 독자가 가장 먼저 붙잡아야 할 질문은 이 숫자가 몇 개인가가 아니라 이 축이 샘플 수인가, 채널인가, 길이인가입니다.

이 결과를 실습 장면으로 바꾸면, shape를 제대로 읽는 사람은 모델이 왜 실행되지 않는가보다 먼저 내가 배치축과 채널축, 토큰축을 어디서 바꿔 읽었는가를 점검하게 됩니다. 반대로 shape를 숫자 묶음으로만 보면, 같은 에러를 반복하면서도 입력 정의를 잘못 잡았다는 사실을 늦게 알아차리기 쉽습니다.

배치와 텐서라는 표현은 단순한 라이브러리 문법이 아니라, 딥러닝이 대규모 병렬 수치 계산 체계로 정착하면서 함께 일반화된 표현입니다. GPU 기반 학습이 확산되면서, 데이터를 배치 하나보다 묶음 단위 tensor로 보는 감각이 사실상 표준이 되었습니다.

Part 2의 선형대수와 NumPy 배열
Part 3의 입력 행렬과 feature table
P5-9.1의 GPU 병렬 처리

가 여기서 하나의 shape 언어로 합쳐지기 때문입니다.

즉, 텐서는 새로운 어려운 개념이라기보다, 앞에서 배운 배열 사고를 딥러닝 규모로 확장한 결과라고 보는 편이 좋습니다.

여기서 한 번 멈추고, 언제 데이터 종류보다 shape와 배치 관점부터 먼저 읽어야 하는가를 짧게 고정해 두면 뒤의 attention, Transformer 계산 설명으로 넘어갈 때 기준선이 덜 흔들립니다.

먼저 떠올릴 질문	배치·텐서 관점이 먼저 필요한 이유	다음 절들에서 이어질 것
입력이 왜 실행되지 않거나 엉뚱한 계산을 하는가	값보다 축 의미와 shape 정합성이 먼저 맞아야 하기 때문	attention에서 query, key, value shape 읽기
표, 이미지, 문장이 왜 모두 같은 계산 언어로 보이는가	데이터 종류가 달라도 텐서와 배치 차원으로 묶이면 공통 연산 구조를 읽을 수 있기 때문	Transformer의 대규모 행렬 계산
여러 샘플을 왜 한 번에 처리하는가	배치 차원이 병렬 계산과 gradient 집계를 가능하게 하기 때문	긴 시퀀스와 큰 배치에서 생기는 계산 부담

체크리스트¶

배치(batch)와 텐서(tensor)가 딥러닝 계산에서 어떤 기본 단위인지 설명할 수 있는가?
여러 샘플을 한꺼번에 계산하는 구조가 GPU 계산과 어떻게 이어지는지 말할 수 있는가?
배치는 여러 샘플을 한꺼번에 처리하는 계산 단위라는 점을 설명할 수 있는가?
텐서는 딥러닝이 다루는 다차원 숫자 배열의 일반 이름이라는 점을 말할 수 있는가?
배치를 샘플 여러 개를 보기 좋게 모아 둔 것이 아니라 같은 계산을 동시에 태우는 단위로 설명할 수 있는가?
(batch_size, sequence_length, embedding_dim) 같은 shape를 볼 때 축 이름을 실제로 분리해 읽을 수 있는가?
shape를 읽을 때 현재 축이 배치인지, 길이인지, 채널인지 구분해 입력과 출력이 기대한 구조와 맞는지 먼저 확인할 수 있는가?
표, 이미지, 문장 데이터를 각기 다른 감각으로만 보지 않고, 텐서와 shape라는 공통 계산 언어로 다시 설명할 수 있는가?

출처와 참고 자료¶

Ian Goodfellow, Yoshua Bengio, Aaron Courville, Deep Learning, MIT Press, 2016, 확인 날짜: 2026-06-29. https://www.deeplearningbook.org/
Aurélien Géron, Hands-On Machine Learning with Scikit-Learn, Keras, and TensorFlow, 3rd ed., O'Reilly, 2022, 확인 날짜: 2026-07-19. https://www.oreilly.com/library/view/hands-on-machine-learning/9781098125967/
NumPy Developers, ndarray, NumPy Documentation, 확인 날짜: 2026-06-29. https://numpy.org/doc/stable/reference/arrays.ndarray.html