[PyTorch] Tensor 데이터 조작 함수 정리

 

🚩Tensor란? 

• Gpu 상에서 병렬 연산을 잘 수행하기 위해서 사용하는 자료형 
• 자동 미분 최적화와 GPU에서 실행된다. 

 

 

🔧 생성

import torch
import numpy as np

# tensor()
x = torch.tensor([1.0, 2.0, 3.0])

# from_numpy()
arr = np.array([4.0, 5.0, 6.0])
y = torch.from_numpy(arr)

 

torch.tensor(data)	Python 리스트/넘파이 배열 등을 텐서로 생성
torch.from_numpy(ndarray)	NumPy 배열을 공유 메모리 기반으로 텐서로 변환 (데이터 공유됨)

 

 

 

 

🔄 형태 변환

 

x = torch.tensor([[1, 2], [3, 4]])

# to()
x.to(torch.float32)

# transpose()
x.T  # 또는 x.transpose(0, 1)

# reshape()
x.reshape(4)

# view()
x.view(-1)  # reshape과 비슷 (메모리 연속성 필요)

# squeeze()
torch.tensor([[[1], [2], [3]]]).squeeze()  # → [1, 2, 3]

# unsqueeze()
torch.tensor([1, 2, 3]).unsqueeze(0)  # → [[1, 2, 3]]

# permute()
x = torch.randn(2, 3, 4)
x.permute(2, 0, 1).shape  # → (4, 2, 3)

# flatten()
x = torch.tensor([[1, 2], [3, 4]])
x.flatten()  # → [1, 2, 3, 4]

# unflatten()
x = torch.tensor([1, 2, 3, 4])
x.unflatten(0, (2, 2))  # → [[1, 2], [3, 4]]

 

to(device)	CPU ↔ GPU로 데이터 이동
transpose(dim0, dim1)	두 차원 위치 바꿈
reshape(shape)	새로운 shape으로 변환 (복사/뷰 둘 다 가능)
view(shape)	reshape과 유사하나, 연속된 메모리일 때만 가능
squeeze(dim)	차원이 1인 dim을 제거 (예: [1, 3, 1] → [3])
unsqueeze(dim)	dim에 차원 1을 추가 (예: [3] → [1, 3])
permute(dims)	차원의 순서를 임의로 재배열
flatten(start_dim, end_dim)	특정 차원 범위를 1차원으로 평탄화
unflatten(dim, sizes)	flatten을 되돌리는 함수

 

 

 

🧩 결합 및 분할

 

a = torch.tensor([[1, 2]])
b = torch.tensor([[3, 4]])

# cat()
torch.cat([a, b], dim=0)  # → [[1, 2], [3, 4]]

# stack()
torch.stack([a, b], dim=0)  # → [[[1, 2]], [[3, 4]]]

# split()
x = torch.tensor([1, 2, 3, 4])
torch.split(x, 2)  # → ([1, 2], [3, 4])

# chunk()
x = torch.tensor([1, 2, 3, 4])
torch.chunk(x, 2)  # → ([1, 2], [3, 4])

# unbind()
x = torch.tensor([[1, 2], [3, 4]])
torch.unbind(x, dim=0)  # → (tensor([1, 2]), tensor([3, 4]))

 

cat(tensors, dim)	주어진 dim을 기준으로 텐서 연결
stack(tensors, dim)	새로운 dim을 만들며 텐서를 연결
split(tensor, split_size, dim)	특정 크기로 나누기
chunk(tensor, chunks, dim)	균등하게 나누기
unbind(tensor, dim)	특정 차원을 기준으로 텐서를 튜플로 분해

 

 

 

📌 인덱싱 및 슬라이싱

 

x = torch.tensor([[10, 20], [30, 40]])

# 일반 인덱싱
x[0, 1]  # → 20

# 슬라이싱
x[:, 1]  # → [20, 40]

# gather()
x = torch.tensor([[1, 2], [3, 4]])
index = torch.tensor([[0, 1], [1, 0]])
torch.gather(x, 1, index)  # → [[1, 2], [4, 3]]

# index_select()
x = torch.tensor([[1, 2, 3], [4, 5, 6]])
idx = torch.tensor([0, 2])
torch.index_select(x, 1, idx)  # → [[1, 3], [4, 6]]

 

tensor[i], tensor[i, j]	일반 인덱싱/슬라이싱
gather(dim, index)	주어진 index에 따라 요소 선택
index_select(dim, index)	주어진 index만 선택하여 텐서 생성

 

 

 

 

➕ 연산

사칙연산

a = torch.tensor([1, 2])
b = torch.tensor([3, 4])

a.add(b)  # → [4, 6]
a.sub(b)  # → [-2, -2]
a.mul(b)  # → [3, 8]
a.div(b)  # → [0.3333, 0.5]

add, sub, mul, div

덧셈, 뺄셈, 곱셈, 나눗셈 (브로드캐스팅 지원)

 

집계 연산

x = torch.tensor([[1.0, 2.0], [3.0, 4.0]])

x.sum()    # → 10.0
x.mean()   # → 2.5
x.max()    # → 4.0
x.min()    # → 1.0
x.std()    # → 표준편차

 

sum, mean, max, min, std

텐서의 합, 평균, 최댓값, 최솟값, 표준편차 등 계산 (dim 지정 가능)

 

 

비교 연산

a = torch.tensor([1, 2, 3])
b = torch.tensor([2, 2, 1])

a.eq(b)  # → [False, True, False]
a.gt(b)  # → [False, False, True]
a.lt(b)  # → [True, False, False]

 

 

eq, ne, gt, lt

같음, 다름, 큼, 작음 비교 결과를 Boolean Tensor로 반환

 

💠기타 함수

x = torch.tensor([1.0, 2.0, 3.0])

# numpy()
x.numpy()  # → NumPy 배열로 변환

# tolist()
x.tolist()  # → [1.0, 2.0, 3.0]

# clone()
y = x.clone()

# to()
x.to(torch.float64)

# expand()
x = torch.tensor([[1], [2], [3]])  # shape: (3, 1)
x.expand(3, 4)  # shape: (3, 4), 값 복제 아님

# repeat()
x = torch.tensor([[1], [2], [3]])
x.repeat(1, 3)  # → [[1, 1, 1], [2, 2, 2], [3, 3, 3]]

# detach()
x = torch.tensor([1.0], requires_grad=True)
y = x * 2
y = y.detach()

 

numpy()	텐서를 넘파이 배열로 변환 (공유 메모리)
tolist()	텐서를 파이썬 리스트로 변환
clone()	텐서 복제 (독립된 복사본)
to(dtype/device)	텐서의 타입 또는 디바이스 변경
expand()	메모리를 공유하면서 브로드캐스트 방식으로 확장
repeat()	값을 복제하여 텐서 크기 확장 (expand와는 방식 다름)
detach()	그래디언트 계산에서 텐서를 분리 (autograd 끊기)