머신러닝: 파이썬 Pytorch 사용하기!

1. torch.rand(a, b) : 0 ~ 1사이의 값을 갖는 a x b 텐서생성 

 

import torch
x = torch.rand(5, 3)
x

 

tensor([[0.2107, 0.1415, 0.2014],
        [0.3747, 0.4420, 0.9662],
        [0.8733, 0.0158, 0.6805],
        [0.8282, 0.7829, 0.2063],
        [0.9674, 0.3998, 0.0489]])

 

tensor형태로 출력

 

 

 

 

 

2. tensor 값 지정해주기 

 

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

 

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

 

 

 

 

 

3. 

torch.zeros(a, b) :  0 값을 가진 a x b의 tensor 생성

torch.ones(a, b) :  1 값을 가진 a x b의 tensor 생성

torch.zeros_like(input) :  input의 크기와 같고 모든 값이 0인 tensor 생성

torch.ones_like(input) :  input의 크기와 같고 모든 값이 1인 tensor 생성

 

 

import torch
x = torch.zeros(3, 4)
y = torch.ones(3, 4)
z = torch.zeros_like(y)
w = torch.zeros_like(x)
print(x)
print(y)
print(z)
print(w)

 

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

 

 

 

 

 

4. torch.eye(a) : 사선 방향이 1인 a x a 텐서 생성

 

x = torch.eye(4)  # digonal한 방향
x

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

 

 

 

 

 

5.

torch.cat((a, b, c ...), dim = 0 or 1) : a, b, c가 쌓이며 dim 값에 따라 a, b, c가 쌓이는 방향이 달라진다. 

torch.stack((a , b, ...), dim = o or 1, out = None) : torch.cat오 같은 방식으로 쌓이지만 텐서의 크기가 같아야 사용할 수 있다.  

 

x = torch.randn(2, 3)
y = torch.cat((x,x,x),0) // dim값 0으로 지정
z = torch.cat((x, x, x), 1)  // dim값 0으로 지정
print(x)
print(y)
print(z)


w = torch.stack((x,x,x), dim = 1, out = None)
print(w)

 

tensor([[-1.1181, -1.0506,  0.2648],  # x값
        [ 1.3131, -1.7046,  1.6205]])
        
tensor([[-1.1181, -1.0506,  0.2648],  # x가 세로방향으로 쌓였다. 
        [ 1.3131, -1.7046,  1.6205],
        [-1.1181, -1.0506,  0.2648],
        [ 1.3131, -1.7046,  1.6205],
        [-1.1181, -1.0506,  0.2648],
        [ 1.3131, -1.7046,  1.6205]])
        
tensor([[-1.1181, -1.0506,  0.2648, -1.1181, -1.0506,  0.2648, -1.1181, -1.0506,
          0.2648],
        [ 1.3131, -1.7046,  1.6205,  1.3131, -1.7046,  1.6205,  1.3131, -1.7046,
          1.6205]])
           # x가 가로방향으로 쌓였다. 
           
tensor([[[-1.1181, -1.0506,  0.2648],
         [-1.1181, -1.0506,  0.2648],
         [-1.1181, -1.0506,  0.2648]],

        [[ 1.3131, -1.7046,  1.6205],
         [ 1.3131, -1.7046,  1.6205],
         [ 1.3131, -1.7046,  1.6205]]])

 

 

 

 

 

6. torch.reshape(input, (a, b)): input값의 shape를 a x b로 바꿔준다. 

 

a = torch.arange(4.)
b = torch.reshape(a, (2, 2))
print(b)
c = torch.reshape(b, (-1, )) # 1행으로 바꿔준다. 
print(c)

 

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

 

 

 

 

 

7. 인덱싱하기 

 

a = torch.arange(4.)
b = torch.reshape(a, (2, 2))
print(b)
print(b[0:,1])
print(b[0,:])

 

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

 

 

 

print(z[1][1])
print(z[1,1])
print(z[1,1].item()) # 속해 있는 값을 가져온다. 

 

tensor(1.7217)
tensor(1.7217)
1.7216795682907104

 

 

 

 

 

8.

torch.clamp(input, a, b):  min값 a, max을 b로 설정해서 input 값을 바꾼다. 

torch.div(input, a): input값 / a
torch.mul(input, a): input x a

 

y = torch.clamp(x,0,1) # 0과 1이에서 min max를 잡고 값을 바꾼다. 
print(y)

y = torch.div(x, 0.5) 
print(x, y)
y = torch.mul(x, 2)
print(x, y)

 

tensor([[0.0000, 0.0000, 0.0000, 0.6829],
        [0.6004, 1.0000, 0.0000, 0.1341],
        [0.2790, 1.0000, 0.0000, 0.1709],
        [1.0000, 0.4177, 1.0000, 0.9498]])
tensor([[-0.5618, -0.0694, -0.8170,  0.6829],
        [ 0.6004,  1.3044, -0.4015,  0.1341],
        [ 0.2790,  1.7217, -1.0786,  0.1709],
        [ 2.4094,  0.4177,  1.0901,  0.9498]]) tensor([[-1.1237, -0.1388, -1.6340,  1.3658],
        [ 1.2008,  2.6089, -0.8029,  0.2682],
        [ 0.5581,  3.4434, -2.1572,  0.3418],
        [ 4.8189,  0.8353,  2.1801,  1.8995]])
tensor([[-0.5618, -0.0694, -0.8170,  0.6829],
        [ 0.6004,  1.3044, -0.4015,  0.1341],
        [ 0.2790,  1.7217, -1.0786,  0.1709],
        [ 2.4094,  0.4177,  1.0901,  0.9498]]) tensor([[-1.1237, -0.1388, -1.6340,  1.3658],
        [ 1.2008,  2.6089, -0.8029,  0.2682],
        [ 0.5581,  3.4434, -2.1572,  0.3418],
        [ 4.8189,  0.8353,  2.1801,  1.8995]])

 

 

 

 

 

9. input.view(a, b) : input의 shape을 a x b로 변경

 

x = torch.randn(4,4)
y = x.view(16)  
z = x.view(-1, 8) # -1은 하나를 알려줄테니까 나머지는 알아서 결정하라는 의미 
                 # 16이므로 나머지는 알아서 2가 된다. 
print(y)
print(z) # 2x8생성 

 

tensor([-0.5618, -0.0694, -0.8170,  0.6829,  0.6004,  1.3044, -0.4015,  0.1341,
         0.2790,  1.7217, -1.0786,  0.1709,  2.4094,  0.4177,  1.0901,  0.9498])
tensor([[-0.5618, -0.0694, -0.8170,  0.6829,  0.6004,  1.3044, -0.4015,  0.1341],
        [ 0.2790,  1.7217, -1.0786,  0.1709,  2.4094,  0.4177,  1.0901,  0.9498]])

 

 

 

 

 

10. operator overloading

 

x = torch.rand(5,3)
y = torch.rand(5,3)
print(x, y,x + y)


result = torch.empty(5,3)
torch.add(x, y,out = result)
print(result)

 

tensor([[0.5946, 0.2836, 0.4804],
        [0.5239, 0.4722, 0.9983],
        [0.3906, 0.8256, 0.6279],
        [0.6325, 0.5011, 0.4516],
        [0.8428, 0.2135, 0.7428]]) tensor([[0.5532, 0.6759, 0.7085],
        [0.1793, 0.1798, 0.8047],
        [0.3841, 0.6795, 0.4387],
        [0.3859, 0.8789, 0.5565],
        [0.2721, 0.6597, 0.2360]]) tensor([[1.1478, 0.9595, 1.1889],
        [0.7032, 0.6520, 1.8030],
        [0.7747, 1.5051, 1.0666],
        [1.0184, 1.3800, 1.0081],
        [1.1148, 0.8731, 0.9788]])
tensor([[1.1478, 0.9595, 1.1889],
        [0.7032, 0.6520, 1.8030],
        [0.7747, 1.5051, 1.0666],
        [1.0184, 1.3800, 1.0081],
        [1.1148, 0.8731, 0.9788]])

 

 

 

 

 

11. reduction operator (최대, 최소, 평균 구하기)

 

mean = torch.mean(x) # 평균구하기 
min = torch.argmin(x)  # 최솟값의 인덱스를 구한다.  
max = torch.argmax(x)  # 최댓값의 인덱스를 구한다. 
max_dim1 = torch.argmax(x, dim=0)   # 열에서 최댓값들의 인덱스 리턴 
max_dim1 = torch.argmax(x, dim=1)   # 행에서 최댓인값들의 인덱스 리턴 

print(mean)
print(min)
print(max)
print(max_dim1)

 

tensor(0.5721)
tensor(13)
tensor(5)
tensor([0, 2, 1, 0, 0])
tensor(2.3558)
tensor([1.3751, 1.1321, 1.5419])

 

 

 

 

 

12. torch.norm(input) : 텐서의 모든 값들을 모두 제곱해서 더한 후 제곱근을 씌운다. 

 

print(torch.norm(x)) # 디폴트값은 모두 제곱해서 더한다음 루트 
print(torch.norm(x, dim=0))

print(x)

norm_of_x = torch.norm(x, dim = 1, keepdim= True) # 행에 대해서 정규화한 후  
 
print(norm_of_x)

normalized_x = x.div(norm_of_x) #행 에 대해서 따로 나누었다 .
print(normalized_x)

print(torch.sum(normalized_x))  # 모두 더한다. 

 

tensor([[0.5946, 0.2836, 0.4804],
        [0.5239, 0.4722, 0.9983],
        [0.3906, 0.8256, 0.6279],
        [0.6325, 0.5011, 0.4516],
        [0.8428, 0.2135, 0.7428]])
tensor([[0.8153],
        [1.2223],
        [1.1083],
        [0.9247],
        [1.1435]])
tensor([[0.7293, 0.3478, 0.5892],
        [0.4286, 0.3864, 0.8167],
        [0.3525, 0.7449, 0.5665],
        [0.6840, 0.5419, 0.4884],
        [0.7370, 0.1867, 0.6496]])
tensor(8.2494)

 

 

 

 

 

 

13. 비교하기, 정렬하기 

 

#비교하기 

x = torch.ge(torch.tensor([[1, 2, 3 ], [3, 4, 5]]), torch.tensor([[2, 1, 3 ], [4, 2, 5]]))
print(x)
# torch.ge는 >=를 의미하며 참이면 True, 거짓이면 False 리턴  

x_2 = torch.reshape(x, (-1,)) # x를 항 행의 텐서로 reshape

y = torch.max(x, dim = 0) # value랑 indice를 둘 다 찾을 수 있다. 
print(y)

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

torch.sort(x, dim = 1, descending=False)  # 텐서를 내림차순으로 정렬

#argsort라는것도 있는데 내림차순 index만 얻을때 사용한다.

 

tensor([[False,  True,  True],
        [False,  True,  True]])
torch.return_types.max(
values=tensor([False,  True,  True]),
indices=tensor([0, 0, 0]))
tensor([[2, 1, 3],
        [4, 2, 1]])
torch.return_types.sort(values=tensor([[1, 2, 3],
        [1, 2, 4]]), indices=tensor([[1, 0, 2],
        [2, 1, 0]]))

 

 

 

 

 

14. cuda 사용하기 

 

cuda가 설치되어 있다면 True 리턴

import torch
print(torch.cuda.is_available())

 

True

 

 

 

 

 

cuda를 이용해서 변수를 만들면 gpu에 올라간다. 

 

변수를 gpu에 올리는 이유는 gpu에 올라간 변수는 cpu에서 연산하는 것보다 빠르기 때문 

 

x = torch.ones((3, 4))  # cpu에서 변수생성

device = torch.device("cuda")
y = torch.ones((3,4), device=device)# gpu에서 변수생성

z = torch.ones((3,4), device=device)# gpu에서 변수생성

 

 

 

x = x.to(device) # 변수를 gpu로 옮겨서 생성 gpu로 올리면 연산이 더 빨라진다
y = y.to(device)

z = x + y  # x와 y 가 gpu에 있으므로 z도 gpu

z = z.to("cpu", torch.double)  # cpu로 생성 

 

 

 

 

 

15. torch <-> numpy

 

1) torch에서 numpy로 바꾸기 

#torch에서 numpy로 바꾸기

x = torch.ones((3, 4))
y = x.numpy()

 

※ 단, cuda device로 올라갔을 경우는 cpu로 올려준 후 진행한다. 

# x가 cuda 디바이스로 올라갔을 때 

# c = x.numpy() (x) : cuda 디바이스로 올라갔을 때 바로 numpy로 
# 바꿀 수 없기 때문에 cpu로 보내준후 바꾸어 주어야한다.

y = x. detach().cpu().numpy() 

 

 

 

 

 

2) numpy에서 torch로 바꾸기 

#numpy에서 torch로 바꾸기
import numpy as np

a = np.ones(10)
b = torch.from_numpy(a)  #1. numpy에서 cpu로 올리면서 torch로 바꾸기

b = torch.from_numpy(a).float().to(device)  # 2. numpy에서 cuda로 올리면서 torch로 바꾸기