[파이토치] 텐서 이해하기
벡터, 행렬, 텐서
스칼라 : 차원이 없는 값, 숫자가 1개
벡터 : 1차원으로 구성된 값, 숫자가 여러개 나열 됨 (그림에서 1d-tensor)
행렬 : 2차원으로 구성된 값 (2d-tensor)
텐서 : 3차원 이상부터 텐서라고 부르지만 벡터를 1차원 텐서, 행렬을 2차원 텐서로 부름
2D Tensor
딥러닝에서는 2차원 텐서를 batch size * dimension으로 표현함
즉, 행렬에서 행의 크기가 batch size, 열의 크기가 dim.
데이터 하나의 크기가 256이라면, 벡터 하나에 숫자가 256개 존재한다는 의미
만약 훈련 데이터가 총 3000개라면, 전체 훈련 데이터의 개수는 3000 * 256개
batch size = 64이면, 컴퓨터는 한번에 64 * 256개의 데이터를 처리
그럼 컴퓨터는 총 47번(3000/64 = 46.875)의 처리를 하게 됨
3D Tensor
이미지나 영상 처리에서는 가로, 세로를 가진 이미지를 가지기 때문에, 위와 같은 3차원 텐서가 됨
자연어 처리 분야에서는 (batch size, 문장 길이, 단어 벡터의 차원)의 3차원 텐서를 사용
1D with PyTorch
파이토치로 1차원 텐서 벡터 t 생성
t = torch.FloatTensor([0., 1., 2., 3., 4., 5., 6.])
print(t.dim()) # rank. 즉, 차원
print(t.shape) # shape
print(t.size()) # shape아래와 같은 결과가 나옴
1
torch.Size([7])
torch.Size([7])
2D with PyTorch
t = torch.FloatTensor([[1., 2., 3.],
[4., 5., 6.],
[7., 8., 9.],
[10., 11., 12.]
])print(t.dim()) # rank. 즉, 차원
print(t.size()) # shape2
torch.Size([4, 3])
print(t[:, 1]) # 첫번째 차원을 전체 선택한 상황에서 두번째 차원의 첫번째 것만 가져온다.
print(t[:, 1].size()) # ↑ 위의 경우의 크기tensor([ 2., 5., 8., 11.])
torch.Size([4])print(t[:, :-1]) # 첫번째 차원을 전체 선택한 상황에서 두번째 차원에서는 맨 마지막에서 첫번째를 제외하고 다 가져온다.tensor([[ 1., 2.],
[ 4., 5.],
[ 7., 8.],
[10., 11.]])
브로드캐스팅(Broadcasting)
행렬의 덧셈과 뺄셈에서는 두 행렬의 크기가 같아야 함
행렬의 곱셈에서는 한 행렬의 마지막 차원과 다른 행렬의 첫번째 차원이 일치해야 함
그러나, 파이토치에서는 자동으로 크기를 맞춰서 연산을 수행하게 만드는 브로드캐스팅 기능이 존재
# Vector + scalar
m1 = torch.FloatTensor([[1, 2]])
m2 = torch.FloatTensor([3]) # [3] -> [3, 3]
print(m1 + m2)
tensor([[4., 5.]])# 2 x 1 Vector + 1 x 2 Vector
m1 = torch.FloatTensor([[1, 2]])
m2 = torch.FloatTensor([[3], [4]]) # [3] -> [3,3] , [4] -> [4, 4]
print(m1 + m2)
tensor([4., 5.],
[5., 6.]])
브로드캐스팅은 자동으로 수행되므로 사용자는 나중에 원하는 결과가 나오지 않았더라도 어디서 문제가 발생했는지 찾기가 굉장히 어려움
행렬 곱셈과 곱셈의 차이 (Matrix Multiplication Vs. Multiplication)
행렬로 곱셈을 하는 방법은 크게 두 가지
바로 행렬 곱셈(.matmul)과 원소 별 곱셈(.mul)
원소 별 곱셈 (element-wise 곱셈)
동일한 크기의 행렬이 동일한 위치에 있는 원소끼리 곱하는 것
아래는 서로 다른 크기의 행렬이 브로드캐스팅이 된 후에 element-wise 곱셈이 수행되는 예시
*이나 mul()을 이용해 사용
m1 = torch.FloatTensor([[1, 2], [3, 4]])
m2 = torch.FloatTensor([[1], [2]]) # [1] -> [1, 1] , [2] -> [2, 2]
print('Shape of Matrix 1: ', m1.shape) # 2 x 2
print('Shape of Matrix 2: ', m2.shape) # 2 x 1
print(m1 * m2) # 2 x 2
print(m1.mul(m2))
Shape of Matrix 1: torch.Size([2, 2])
Shape of Matrix 2: torch.Size([2, 1])
tensor([[1., 2.],
[6., 8.]])
tensor([[1., 2.],
[6., 8.]])
평균 구하기
1차원 평균
t = torch.FloatTensor([1, 2])
print(t.mean()) #tensor(1.5000)
2차원 평균
t = torch.FloatTensor([[1, 2], [3, 4]])
print(t.mean()) # tensor(2.5000)4개의 원소의 평균인 2.5가 나옴
2차원 평균을 구할 때, 차원을 인자로 주는 경우
print(t.mean(dim=0)) #tensor([2., 3.])dim=0이라는 것은 첫번째 차원을 의미
dim을 인자로 준다는 것은 해당 차원(행)을 제거한다는 것
다시 말해 '열'만 남기겠다는 것 -> (1,2)의 행렬 크기를 가지게 됨
print(t.mean(dim=1)) # tensor([1.5000, 3.5000])각 행(row)에 대해 열(column) 방향으로 평균을 계산
열의 차원이 제거되어야 하므로 (2, 2)의 크기에서 (2, 1)의 크기가 됨
하지만 (2 × 1)은 결국 1차원이므로 (1 × 2)와 같이 표현되면서 위와 같이 [1.5, 3.5]로 출력
덧셈
t = torch.FloatTensor([[1, 2], [3, 4]])
print(t.sum()) # 단순히 원소 전체의 덧셈을 수행
print(t.sum(dim=0)) # 행을 제거
print(t.sum(dim=1)) # 열을 제거
print(t.sum(dim=-1)) # 열을 제거
tensor(10.)
tensor([4., 6.])
tensor([3., 7.])
tensor([3., 7.])
View
원소의 수를 유지하면서 텐서의 크기 변경
파이토치 텐서의 뷰(View)는 넘파이에서의 리쉐이프(Reshape)와 같은 역할
t = np.array([[[0, 1, 2],
[3, 4, 5]],
[[6, 7, 8],
[9, 10, 11]]])
ft = torch.FloatTensor(t)
print(ft.shape) # torch.Size([2, 2, 3])
1) 3차원 텐서에서 2차원 텐서로 변경
print(ft.view([-1, 3])) # ft라는 텐서를 (?, 3)의 크기로 변경
print(ft.view([-1, 3]).shape)tensor([[ 0., 1., 2.],
[ 3., 4., 5.],
[ 6., 7., 8.],
[ 9., 10., 11.]])
torch.Size([4, 3])-1은 첫번째 차원은 사용자가 잘 모르겠으니 파이토치에 맡기겠다는 의미이고,
3은 두번째 차원의 길이는 3을 가지도록 하라는 의미
내부적으로 크기 변환은 다음과 같이 이루어 짐. (2, 2, 3) -> (2 × 2, 3) -> (4, 3)
view의 규칙
- view는 기본적으로 변경 전과 변경 후의 텐서 안의 원소의 개수가 유지되어야 합니다.
- 파이토치의 view는 사이즈가 -1로 설정되면 다른 차원으로부터 해당 값을 유추합니다.
2) 3차원 텐서의 크기 변경
3차원 텐서에서 3차원 텐서로 차원은 유지하되, 크기(shape)를 바꾸는 작업
(2 × 2 × 3) 텐서를 (? × 1 × 3) 텐서로 변경하라고 하면 ?는 몇 차원?
?는 4
print(ft.view([-1, 1, 3]))
print(ft.view([-1, 1, 3]).shape)tensor([[[ 0., 1., 2.]],
[[ 3., 4., 5.]],
[[ 6., 7., 8.]],
[[ 9., 10., 11.]]])
torch.Size([4, 1, 3])
Squeeze
스퀴즈는 차원이 1인 경우에는 해당 차원을 제거
ft = torch.FloatTensor([[0], [1], [2]])
print(ft)
print(ft.shape)tensor([[0.],
[1.],
[2.]])
torch.Size([3, 1])print(ft.squeeze())
print(ft.squeeze().shape)tensor([0., 1., 2.])
torch.Size([3])1이었던 두번째 차원이 제거되면서 (3,)의 크기를 가지는 텐서로 변경되어 1차원 벡터가 된 것
Unsqueeze
특정 위치에 1인 차원을 추가
ft = torch.Tensor([0, 1, 2])
print(ft.shape)torch.Size([3])현재는 차원이 1개인 1차원 벡터
첫번째 차원에 1인 차원을 추가
print(ft.unsqueeze(0)) # 인덱스가 0부터 시작하므로 0은 첫번째 차원을 의미한다.
print(ft.unsqueeze(0).shape)tensor([[0., 1., 2.]])
torch.Size([1, 3])
Concat
두 텐서를 연결하는 방법
x = torch.FloatTensor([[1, 2], [3, 4]])
y = torch.FloatTensor([[5, 6], [7, 8]])print(torch.cat([x, y], dim=0))
tensor([[1., 2.],
[3., 4.],
[5., 6.],
[7., 8.]])dim=0을 인자로 했더니 두 개의 (2 × 2) 텐서가 (4 × 2) 텐서가 됨
print(torch.cat([x, y], dim=1))
tensor([[1., 2., 5., 6.],
[3., 4., 7., 8.]])dim=1을 인자로 했더니 두 개의 (2 × 2) 텐서가 (2 × 4) 텐서가 됨
Stacking
x = torch.FloatTensor([1, 4])
y = torch.FloatTensor([2, 5])
z = torch.FloatTensor([3, 6])
print(torch.stack([x, y, z]))
tensor([[1., 4.],
[2., 5.],
[3., 6.]])
위 stack 방법은 아래와 같음
print(torch.cat([x.unsqueeze(0), y.unsqueeze(0), z.unsqueeze(0)], dim=0))x, y, z는 기존에는 전부 (2,)의 크기를 가짐
그런데 .unsqueeze(0)을 하므로서 3개의 벡터는 전부 (1, 2)의 크기의 2차원 텐서로 변경
위에서는 torch.stack([x, y, z])라는 한 번의 커맨드로 수행했지만,
연결(concatenate)로 이를 구현하려고 했더니 꽤 복잡해짐
print(torch.stack([x, y, z], dim=1))
tensor([[1., 2., 3.],
[4., 5., 6.]])
ones_like와 zeros_like - 0으로 채워진 텐서와 1로 채워진 텐서
x = torch.FloatTensor([[0, 1, 2], [2, 1, 0]])
print(x)
tensor([[0., 1., 2.],
[2., 1., 0.]])print(torch.ones_like(x)) # 입력 텐서와 크기를 동일하게 하면서 값을 1로 채우기
tensor([[1., 1., 1.],
[1., 1., 1.]])
Reference