[PyTorch] 1.PyTorch Basic

파이토치는 텐서플로우의 라이벌 격이라고 보면된다.

 

텐서플로우처럼 Numpy와 상호보완적이며, 배열을 tensor로 변경할수 있고

 

학습도 동일하게 할수있다, 최근에는 편의성이 좋아서 텐서플로우보다 많이 사용되어 지고 있다고 한다.

 

 

 

In [1]:

import numpy as np
import torch

In [3]:

#tensorflow랑 똑같은 역할인데 좀더 세련됨

nums = torch.arange(9)
nums

Out[3]:

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

In [4]:

type(nums)

Out[4]:

torch.Tensor

In [5]:

nums.numpy() #numpy로 변환 가능

Out[5]:

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

In [6]:

nums.reshape(3,3)

Out[6]:

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

In [7]:

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

Out[7]:

tensor([[0.4383, 0.4503, 0.6859],
        [0.5727, 0.1216, 0.6770],
        [0.1521, 0.6160, 0.2441]])

In [8]:

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

Out[8]:

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

In [9]:

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

Out[9]:

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

In [10]:

torch.zeros_like(ones)

Out[10]:

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

In [11]:

zeros.size()

Out[11]:

torch.Size([3, 3])

 

Operations¶

PyTorch로 수학연산

In [13]:

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 [17]:

nums + nums
torch.add(nums,3)

Out[17]:

tensor([[ 3,  4,  5],
        [ 6,  7,  8],
        [ 9, 10, 11]])

In [18]:

result = torch.add(nums,10)
result.numpy()

Out[18]:

array([[10, 11, 12],
       [13, 14, 15],
       [16, 17, 18]], dtype=int64)

 

View¶

걍 reshape랑 똑같다

In [19]:

range_nums = torch.arange(9).reshape(3,3)
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 [23]:

range_nums.view(3,3) 

Out[23]:

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

 

Slice and Index¶

In [24]:

nums

Out[24]:

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

In [25]:

nums[1]

Out[25]:

tensor([3, 4, 5])

In [26]:

nums[1,1]

Out[26]:

tensor(4)

In [29]:

nums[1:,1:]

Out[29]:

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

 

Compile¶

In [30]:

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

In [31]:

arr_torch = torch.from_numpy(arr) #numpy를 torch로 변환

In [32]:

arr_torch.float()

Out[32]:

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

In [36]:

# Gpu가 있다면 자동으로 Gpu를 사용해서 학습하라는 얘기
device = 'cuda' if torch.cuda.is_available() else 'cpu'
device

Out[36]:

'cuda'

In [37]:

arr_torch.to(device)

Out[37]:

tensor([1, 1, 1], device='cuda:0', dtype=torch.int32)

 

AutoGrad¶

In [38]:

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

Out[38]:

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

In [39]:

y= x+2
y

Out[39]:

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

In [40]:

print(y.grad_fn)

 

<AddBackward0 object at 0x000001D733C1DF10>

In [41]:

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

In [42]:

print(z,out)

 

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

In [43]:

out.backward()

In [44]:

print(x.grad) # x의 기울기

 

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

In [45]:

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

 

True
True

In [46]:

#학습에 필요없는것들은 제외할수 있어서 속도를 빠르게 할수 있음
with torch.no_grad():
    print((x**2).requires_grad)

 

False

In [ ]: