[PyTorch] 기본 사용법

PyTorch Basic¶

넘파이와 토치의 비교 및 기초 사용법

In [1]:

import numpy as np
import torch

import warnings
warnings.filterwarnings('ignore')

In [2]:

np.arange(9)

Out[2]:

array([0, 1, 2, 3, 4, 5, 6, 7, 8])

In [3]:

nums = torch.arange(9)
nums

Out[3]:

tensor([0, 1, 2, 3, 4, 5, 6, 7, 8])

In [4]:

#토치 모양 보기
nums.shape

Out[4]:

torch.Size([9])

In [5]:

#토치 타입보기
type(nums)

Out[5]:

torch.Tensor

In [6]:

# 넘파이로 변환
nums.numpy()

Out[6]:

array([0, 1, 2, 3, 4, 5, 6, 7, 8], dtype=int64)

In [7]:

# 쉐잎 변환 가능
nums.reshape(3,3)

Out[7]:

tensor([[0, 1, 2],
        [3, 4, 5],
        [6, 7, 8]])

In [8]:

random = torch.rand((3,3))
random

Out[8]:

tensor([[0.3382, 0.8482, 0.7422],
        [0.1245, 0.5603, 0.6892],
        [0.8257, 0.3108, 0.9058]])

In [9]:

zeros = torch.zeros((3,3))
zeros

Out[9]:

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

In [10]:

ones = torch.ones((3,3))
ones

Out[10]:

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

In [11]:

torch.zeros_like(ones)

Out[11]:

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

In [12]:

zeros.size()

Out[12]:

torch.Size([3, 3])

Operations¶

PyTorch로 수학연산

In [13]:

#broad cast가 가능하다.
nums * 3

Out[13]:

tensor([ 0,  3,  6,  9, 12, 15, 18, 21, 24])

In [14]:

nums = nums.reshape((3,3))
nums

Out[14]:

tensor([[0, 1, 2],
        [3, 4, 5],
        [6, 7, 8]])

In [15]:

nums + nums

Out[15]:

tensor([[ 0,  2,  4],
        [ 6,  8, 10],
        [12, 14, 16]])

In [16]:

result = torch.add(nums,3)

In [17]:

result.numpy()

Out[17]:

array([[ 3,  4,  5],
       [ 6,  7,  8],
       [ 9, 10, 11]], dtype=int64)

View¶

In [18]:

# 공홈에 보면 view가 있지만 reshape을 사용하라고 권고하고 있다. 간단한 것만 알고가자
range_nums = torch.arange(9).reshape(3,3)

In [19]:

range_nums

Out[19]:

tensor([[0, 1, 2],
        [3, 4, 5],
        [6, 7, 8]])

In [20]:

range_nums.view(-1)

Out[20]:

tensor([0, 1, 2, 3, 4, 5, 6, 7, 8])

In [21]:

range_nums.view(1,9)

Out[21]:

tensor([[0, 1, 2, 3, 4, 5, 6, 7, 8]])

Slice and index¶

In [22]:

nums

Out[22]:

tensor([[0, 1, 2],
        [3, 4, 5],
        [6, 7, 8]])

In [23]:

nums[1]

Out[23]:

tensor([3, 4, 5])

In [24]:

nums[1,1]

Out[24]:

tensor(4)

In [25]:

nums[1:,1:]

Out[25]:

tensor([[4, 5],
        [7, 8]])

In [26]:

nums[:,2]

Out[26]:

tensor([2, 5, 8])

In [27]:

nums[:1,:1]

Out[27]:

tensor([[0]])

Compile¶

In [28]:

arr = np.array([1,1,1])
arr

Out[28]:

array([1, 1, 1])

In [29]:

arr_torch = torch.from_numpy(arr)
arr_torch

Out[29]:

tensor([1, 1, 1], dtype=torch.int32)

In [30]:

arr_torch.float()

Out[30]:

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

In [31]:

device = 'cuda' if torch.cuda.is_available() else 'cpu'

In [32]:

arr_torch.to(device)

Out[32]:

tensor([1, 1, 1], dtype=torch.int32)

In [33]:

device

Out[33]:

'cpu'

AutoGrad¶

In [34]:

x = torch.ones(2,2,requires_grad=True)
x

Out[34]:

tensor([[1., 1.],
        [1., 1.]], requires_grad=True)

In [35]:

y = x + 2
y

Out[35]:

tensor([[3., 3.],
        [3., 3.]], grad_fn=<AddBackward0>)

In [36]:

print(y.grad_fn)

<AddBackward0 object at 0x000001EFB39EDD90>

In [37]:

z = y * y * 3
out = z.mean()

In [39]:

print(z,out)

tensor([[27., 27.],
        [27., 27.]], grad_fn=<MulBackward0>) tensor(27., grad_fn=<MeanBackward0>)

In [40]:

out.backward()

In [41]:

x.grad # x 의 기울기는 4.5이다.

Out[41]:

tensor([[4.5000, 4.5000],
        [4.5000, 4.5000]])

In [42]:

print(x.requires_grad)
print((x**2).requires_grad)

True
True

In [43]:

with torch.no_grad(): # 작동속도가 좀더 빠르다 이유는 기울기를 안 주기 때문.
    print((x**2).requires_grad)

False