[PyTorch] 파이토치 기본 조작2 - view, Squeeze, Unsqueeze, Type Casting, concatenate, Stacking, ones_like와 zeros_like, In-place Operation

¶

In [1]:

import numpy as np
import torch

뷰(View) - 원소의 수를 유지하면서 텐서의 크기 변경¶

파이토치 텐서의 뷰(View)는 넘파이에서의 리쉐이프(Reshape)와 같은 역할¶

In [3]:

t= np.array([[[0, 1, 2],
               [3, 4, 5]],
              [[6, 7, 8],
               [9, 10, 11]]])

In [4]:

ft = torch.FloatTensor(t)

In [5]:

print(ft.shape)

torch.Size([2, 2, 3])

3차원 텐서에서 2차원 텐서로 변경¶

In [6]:

ft.view([-1,3])

Out[6]:

tensor([[ 0.,  1.,  2.],
        [ 3.,  4.,  5.],
        [ 6.,  7.,  8.],
        [ 9., 10., 11.]])

In [8]:

ft.view([-1,3]).shape

Out[8]:

torch.Size([4, 3])

view는 기본적으로 변경 전과 변경 후의 텐서 안의 원소의 개수가 유지되어야 한다.¶

파이토치의 view는 사이즈가 -1로 설정되면 다른 차원으로부터 해당 값을 유추¶

변경 전 텐서의 원소의 수는 (2 × 2 × 3) = 12개¶

변경 후 텐서의 원소의 개수 또한 (4 × 3) = 12개¶

(2 × 2 × 3) 텐서를 (? × 1 × 3) 텐서로 변경¶

In [9]:

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])

원소 갯수가 12개 이므로 (4 X 1 X 3)이 됨¶

In [ ]:

스퀴즈(Squeeze) - 1인 차원을 제거¶

In [10]:

ft = torch.FloatTensor([[0], [1], [2]])
print(ft)
print(ft.shape)

tensor([[0.],
        [1.],
        [2.]])
torch.Size([3, 1])

In [11]:

print(ft.squeeze())
print(ft.squeeze().shape)

tensor([0., 1., 2.])
torch.Size([3])

(3 × 1)의 크기 에서 1인 차원이 사라지고 (3,)의 1차원 벡터가 된다.¶

In [ ]:

언스퀴즈(Unsqueeze) - 특정 위치에 1인 차원을 추가¶

In [12]:

ft = torch.Tensor([0, 1, 2])
print(ft.shape)

torch.Size([3])

In [13]:

print(ft.unsqueeze(0)) # 인덱스가 0부터 시작하므로 0은 첫번째 차원을 의미
print(ft.unsqueeze(0).shape)

tensor([[0., 1., 2.]])
torch.Size([1, 3])

In [17]:

print(ft.unsqueeze(1))
print(ft.unsqueeze(1).shape)

tensor([[0.],
        [1.],
        [2.]])
torch.Size([3, 1])

-1은 인덱스 상으로 마지막 차원을 의미¶

현재 크기는 (3,)이었으므로 마지막 차원에 1인 차원을 추가하면 (3, 1)의 크기를 가지게 됨.¶

(3,)의 경우에는 1을 넣은 경우와 -1을 넣은 경우가 결과가 동일.¶

In [18]:

print(ft.unsqueeze(-1))
print(ft.unsqueeze(-1).shape)

tensor([[0.],
        [1.],
        [2.]])
torch.Size([3, 1])

In [ ]:

타입 캐스팅(Type Casting)¶

타입 캐스팅 = PyTorch에 있는 여러 자료형을 변환하는 것¶

GPU연산을 위한 GPU 데이터 타입이 있는 것이 특징¶

In [22]:

lt = torch.LongTensor([1,2,3,4])
type(lt)

Out[22]:

torch.Tensor

In [23]:

lt.float()

Out[23]:

tensor([1., 2., 3., 4.])

In [27]:

lt.float().dtype

Out[27]:

torch.float32

In [28]:

# Byte 타입의 bt텐서
bt = torch.ByteTensor([True, False, False, True])
print(bt)

tensor([1, 0, 0, 1], dtype=torch.uint8)

In [32]:

# .long으로 타입 캐스팅을 하면 int64
# .float으로 타입 캐스팅을 하면 float32로 변환됨
print(bt.long())
print(bt.float())

tensor([1, 0, 0, 1])
tensor([1., 0., 0., 1.])

In [31]:

print(bt.long().dtype)
print(bt.float().dtype)

torch.int64
torch.float32

In [34]:

print(bt.double())

tensor([1., 0., 0., 1.], dtype=torch.float64)

In [ ]:

concatenate 텐서 연결하기¶

In [41]:

x = torch.FloatTensor([[1, 2], [3, 4]])
y = torch.FloatTensor([[5, 6], [7, 8]])

In [49]:

print(x.shape)
print(y.shape)

torch.Size([2, 2])
torch.Size([2, 2])

In [51]:

# touch.cat([])로 연결하기
# dim = 0 일 경우 행이 늘어난다.
dim0 = torch.cat([x,y], dim=0)
print(dim0)
print(dim0.shape)

tensor([[1., 2.],
        [3., 4.],
        [5., 6.],
        [7., 8.]])
torch.Size([4, 2])

In [52]:

# dim 1을 주면 (2,2) => (2,4)
# 즉 열이 늘어난다.
dim1= torch.cat([x,y], dim=1)
print(dim1)
print(dim1.shape)

tensor([[1., 2., 5., 6.],
        [3., 4., 7., 8.]])
torch.Size([2, 4])

스택킹(Stacking)¶

In [53]:

x = torch.FloatTensor([1, 4])
y = torch.FloatTensor([2, 5])
z = torch.FloatTensor([3, 6])

In [65]:

# 위의 텐서를 (3,2)의 형태로 만들기 위해서는 unsqueeze(0)를 통해서
# 차원 추가를 한 후 cat으로 합쳐야 한다.
print(x.unsqueeze(0))
x.unsqueeze(0).shape

tensor([[1., 4.]])

Out[65]:

torch.Size([1, 2])

In [67]:

# x,y,z를 모두 (1,2)로 바꾸고 cat([]) dim = 0 방향으로 합치면
# (3,2) 의 텐서가 된다. 
catxyz = torch.cat([x.unsqueeze(0), y.unsqueeze(0), z.unsqueeze(0)], dim=0)
print(catxyz)
print(catxyz.shape)

tensor([[1., 4.],
        [2., 5.],
        [3., 6.]])
torch.Size([3, 2])

In [69]:

# stack([])을 사용하면 위의 복잡한 작업 없이 한 번에 (3,2)의 텐서로 만들 수 있음
stackxyz = torch.stack([x, y, z])
print(stackxyz)
print(stackxyz.shape)

tensor([[1., 4.],
        [2., 5.],
        [3., 6.]])
torch.Size([3, 2])

In [71]:

# stack에 옵션으로 dim=1을 주면 열을 기준으로 잘라서 합쳐주기 때문에
# (2,3) 형태의 텐서가 된다.
stackxyzdim1 = torch.stack([x, y, z], dim=1)
print(stackxyzdim1)
print(stackxyzdim1.shape)

tensor([[1., 2., 3.],
        [4., 5., 6.]])
torch.Size([2, 3])

In [ ]:

ones_like와 zeros_like - 0으로 채워진 텐서와 1로 채워진 텐서¶

In [73]:

# (2,3)의 텐서 생성
x = torch.FloatTensor([[0, 1, 2], [2, 1, 0]])
print(x)

tensor([[0., 1., 2.],
        [2., 1., 0.]])

In [76]:

# ones_like로 동일한 shape에 1로 채워진 텐서 생성
# numpy의 ones_like와 동일함
print(torch.ones_like(x))

tensor([[1., 1., 1.],
        [1., 1., 1.]])

In [77]:

# zeros_like로 동일한 shape에 0으로 채워진 텐서 생성
# numpy의 zeros_like와 동일
print(torch.zeros_like(x))

tensor([[0., 0., 0.],
        [0., 0., 0.]])

In [ ]:

In-place Operation (덮어쓰기 연산)¶

In [79]:

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

Out[79]:

tensor([[1., 2.],
        [3., 4.]])

In [83]:

# .mul 연산은 기본적으로 값이 저장되지 않고 결과만 출력한다.
print(x.mul(2.))
print(x)

tensor([[2., 4.],
        [6., 8.]])
tensor([[1., 2.],
        [3., 4.]])

In [ ]:

# mul뒤에 _를 붙이면 덮어쓰기 연산이 된다.

In [84]:

x2 = x
x.mul_(2.)
print(x)
print(x2)

tensor([[2., 4.],
        [6., 8.]])
tensor([[2., 4.],
        [6., 8.]])

In [ ]:

In [ ]:

In [ ]:

In [ ]:

In [ ]:

In [ ]: