Pytorch_Basic

 

 

 

---

TENSOR MANIPULATION : 텐서 조작¶

---

In [5]:

import torch
import numpy as np

# 1차원
print('*'*20)
print('1D TORCH')
print('*'*20)

t = torch.FloatTensor([0,1,2,3,4,5,6])
print(t)
print(t.dim())  # rank. 즉, 차원
print(t.shape)  # shape
print(t.size()) # shape
print(t[0], t[1], t[-1])  # 인덱스로 접근
print(t[2:5], t[4:-1])    # 슬라이싱
print(t[:2], t[3:])       # 슬라이싱


# 2차원
print('\n')
print('*'*20)
print('2D TORCH')
print('*'*20)

t = torch.FloatTensor([[1., 2., 3.],
                       [4., 5., 6.],
                       [7., 8., 9.],
                       [10., 11., 12.]
                      ])

print(t)
print(t.dim())  # rank. 즉, 차원
print(t.size()) # shape
print(t[:, 1]) # 첫번째 차원을 전체 선택한 상황에서 두번째 차원의 첫번째 것만 가져온다.
print(t[:, 1].size()) # ↑ 위의 경우의 크기
print(t[:, :-1]) # 첫번째 차원을 전체 선택한 상황에서 두번째 차원에서는 맨 마지막에서 첫번째를 제외하고 다 가져온다.


# Broadcasting
print('\n')
print('*'*20)
print('BROADCASTING')
print('*'*20)

m1 = torch.FloatTensor([[3, 3]])
m2 = torch.FloatTensor([[2, 2]])
print(m1 + m2)

# Vector + scalar
m1 = torch.FloatTensor([[1, 2]])
m2 = torch.FloatTensor([3]) # [3] -> [3, 3]
print(m1 + m2)

# 2 x 1 Vector + 1 x 2 Vector
m1 = torch.FloatTensor([[1, 2]])
m2 = torch.FloatTensor([[3], [4]])
print(m1 + m2)


# Calculation
print('\n')
print('*'*20)
print('CALCULATION')
print('*'*20)

# matmul
m1 = torch.FloatTensor([[1, 2], [3, 4]])
m2 = torch.FloatTensor([[1], [2]])
print('Shape of Matrix 1: ', m1.shape) # 2 x 2
print('Shape of Matrix 2: ', m2.shape) # 2 x 1
print(m1.matmul(m2)) # 2 x 1

# x.mul()
m1 = torch.FloatTensor([[1, 2], [3, 4]])
m2 = torch.FloatTensor([[1], [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))

# mean
t = torch.FloatTensor([1, 2])
print(t.mean())

t = torch.FloatTensor([[1, 2], [3, 4]])
print(t.mean())
print(t.mean(dim=0))
print(t.mean(dim=1))

# sum
t = torch.FloatTensor([[1, 2], [3, 4]])
print(t)
print(t.sum()) # 단순히 원소 전체의 덧셈을 수행
print(t.sum(dim=0)) # 행을 제거
print(t.sum(dim=1)) # 열을 제거
print(t.sum(dim=-1)) # 열을 제거

 

********************
1D TORCH
********************
tensor([0., 1., 2., 3., 4., 5., 6.])
1
torch.Size([7])
torch.Size([7])
tensor(0.) tensor(1.) tensor(6.)
tensor([2., 3., 4.]) tensor([4., 5.])
tensor([0., 1.]) tensor([3., 4., 5., 6.])


********************
2D TORCH
********************
tensor([[ 1.,  2.,  3.],
        [ 4.,  5.,  6.],
        [ 7.,  8.,  9.],
        [10., 11., 12.]])
2
torch.Size([4, 3])
tensor([ 2.,  5.,  8., 11.])
torch.Size([4])
tensor([[ 1.,  2.],
        [ 4.,  5.],
        [ 7.,  8.],
        [10., 11.]])


********************
BROADCASTING
********************
tensor([[5., 5.]])
tensor([[4., 5.]])
tensor([[4., 5.],
        [5., 6.]])


********************
CALCULATION
********************
Shape of Matrix 1:  torch.Size([2, 2])
Shape of Matrix 2:  torch.Size([2, 1])
tensor([[ 5.],
        [11.]])
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.]])
tensor(1.5000)
tensor(2.5000)
tensor([2., 3.])
tensor([1.5000, 3.5000])
tensor([[1., 2.],
        [3., 4.]])
tensor(10.)
tensor([4., 6.])
tensor([3., 7.])
tensor([3., 7.])

In [7]:

# View 
print('*'*20)
print('VIEW (=numpy.reshape)')
print('*'*20)

t = np.array([[[0, 1, 2],
               [3, 4, 5]],
              [[6, 7, 8],
               [9, 10, 11]]])
ft = torch.FloatTensor(t)
print(ft)
print('shape = ',ft.shape)
print('view 사용 -> ',ft.view([-1, 3])) # ft라는 텐서를 (?, 3)의 크기로 변경
print('view 사용 shape -> ',ft.view([-1, 3]).shape)


# Squeeze 
print('\n')
print('*'*20)
print('SQUEEZE : 1차원 제거')
print('*'*20)

ft = torch.FloatTensor([[0], [1], [2]])
print(ft)
print('shape = ',ft.shape)
print('Squeeze 사용 -> ',ft.squeeze())
print('Squeeze 사용 shape -> ',ft.squeeze().shape)


# Unsqueeze 
print('\n')
print('*'*20)
print('UNSQUEEZE : 1차원 추가')
print('*'*20)

ft = torch.Tensor([0, 1, 2])
print(ft)
print('shape = ',ft.shape)
print('unsqueeze(0) 사용 -> ',ft.unsqueeze(0)) # 인덱스가 0부터 시작하므로 0은 첫번째 차원을 의미한다.
print('unsqueeze(0) 사용 shape -> ',ft.unsqueeze(0).shape)

print('view 사용 -> ',ft.view(1, -1)) # view로도 구현 가능
print('view 사용 shape -> ',ft.view(1, -1).shape)

print('unsqueeze(1) 사용 -> ',ft.unsqueeze(1))
print('unsqueeze(1) 사용 shape -> ',ft.unsqueeze(1).shape)

print('unsqueeze(-1) 사용 -> ',ft.unsqueeze(-1))
print('unsqueeze(-1) 사용 shape -> ',ft.unsqueeze(-1).shape)


# Type Casting 
print('\n')
print('*'*20)
print('TYPE CASTING : 자료형 변환')
print('*'*20)

lt = torch.LongTensor([1, 2, 3, 4])
print(lt)
print(lt.float())
bt = torch.ByteTensor([True, False, False, True])
print(bt)
print(bt.long())
print(bt.float())


# Concatenate : x.cat([])
print('\n')
print('*'*20)
print('CONCATENATE : 텐서 연결')
print('*'*20)

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


# Stacking : x.stack([])
print('\n')
print('*'*20)
print('STACKING : 텐서 쌓기')
print('*'*20)

x = torch.FloatTensor([1, 4])
y = torch.FloatTensor([2, 5])
z = torch.FloatTensor([3, 6])
print(torch.stack([x, y, z]))
print(torch.cat([x.unsqueeze(0), y.unsqueeze(0), z.unsqueeze(0)], dim=0)) # stack과 동일한 작업
print(torch.stack([x, y, z], dim=1))


# Fill : ones_like / zeros_like
print('\n')
print('*'*20)
print('FILL : 텐서 채우기')
print('*'*20)

x = torch.FloatTensor([[0, 1, 2], [2, 1, 0]])
print(x)
print(torch.ones_like(x)) # 입력 텐서와 크기를 동일하게 하면서 값을 1로 채우기
print(torch.zeros_like(x)) # 입력 텐서와 크기를 동일하게 하면서 값을 0으로 채우기


# In-place Operation : mul_
print('\n')
print('*'*20)
print('INPLACE OPERATION : 덮어쓰기')
print('*'*20)

x = torch.FloatTensor([[1, 2], [3, 4]])
print(x.mul(2.)) # 곱하기 2를 수행한 결과를 출력
print('mul사용 저장X -> ',x) # 기존의 값 출력
print(x.mul_(2.))  # 곱하기 2를 수행한 결과를 변수 x에 값을 저장하면서 결과를 출력
print('mul_사용 저장O -> ',x) # 기존의 값 출력

 

********************
VIEW (=numpy.reshape)
********************
tensor([[[ 0.,  1.,  2.],
         [ 3.,  4.,  5.]],

        [[ 6.,  7.,  8.],
         [ 9., 10., 11.]]])
shape =  torch.Size([2, 2, 3])
view 사용 ->  tensor([[ 0.,  1.,  2.],
        [ 3.,  4.,  5.],
        [ 6.,  7.,  8.],
        [ 9., 10., 11.]])
view 사용 shape ->  torch.Size([4, 3])


********************
SQUEEZE : 1차원 제거
********************
tensor([[0.],
        [1.],
        [2.]])
shape =  torch.Size([3, 1])
Squeeze 사용 ->  tensor([0., 1., 2.])
Squeeze 사용 shape ->  torch.Size([3])


********************
UNSQUEEZE : 1차원 추가
********************
tensor([0., 1., 2.])
shape =  torch.Size([3])
unsqueeze(0) 사용 ->  tensor([[0., 1., 2.]])
unsqueeze(0) 사용 shape ->  torch.Size([1, 3])
view 사용 ->  tensor([[0., 1., 2.]])
view 사용 shape ->  torch.Size([1, 3])
unsqueeze(1) 사용 ->  tensor([[0.],
        [1.],
        [2.]])
unsqueeze(1) 사용 shape ->  torch.Size([3, 1])
unsqueeze(-1) 사용 ->  tensor([[0.],
        [1.],
        [2.]])
unsqueeze(-1) 사용 shape ->  torch.Size([3, 1])


********************
TYPE CASTING : 자료형 변환
********************
tensor([1, 2, 3, 4])
tensor([1., 2., 3., 4.])
tensor([1, 0, 0, 1], dtype=torch.uint8)
tensor([1, 0, 0, 1])
tensor([1., 0., 0., 1.])


********************
CONCATENATE : 텐서 연결
********************
tensor([[1., 2.],
        [3., 4.],
        [5., 6.],
        [7., 8.]])
tensor([[1., 2., 5., 6.],
        [3., 4., 7., 8.]])


********************
STACKING : 텐서 쌓기
********************
tensor([[1., 4.],
        [2., 5.],
        [3., 6.]])
tensor([[1., 4.],
        [2., 5.],
        [3., 6.]])
tensor([[1., 2., 3.],
        [4., 5., 6.]])


********************
FILL : 텐서 채우기
********************
tensor([[0., 1., 2.],
        [2., 1., 0.]])
tensor([[1., 1., 1.],
        [1., 1., 1.]])
tensor([[0., 0., 0.],
        [0., 0., 0.]])


********************
INPLACE OPERATION : 덮어쓰기
********************
tensor([[2., 4.],
        [6., 8.]])
mul사용 저장X ->  tensor([[1., 2.],
        [3., 4.]])
tensor([[2., 4.],
        [6., 8.]])
mul_사용 저장O ->  tensor([[2., 4.],
        [6., 8.]])

 

---

CLASS¶

---

In [13]:

# Function
print('*'*20)
print('FUNCTION')
print('*'*20)
result1 = 0
result2 = 0

def add1(num):
    global result1
    result1 += num
    return result1

def add2(num):
    global result2
    result2 += num
    return result2

print('function1 -> ', add1(3), add1(4))
print('function2 -> ', add2(3), add2(7))


# Class
print('\n')
print('*'*20)
print('CLASS')
print('*'*20)

class Calculator:
    def __init__(self): # 객체 생성 시 호출될 때 실행되는 초기화 함수. 이를 생성자라고 한다.
        self.result = 0

    def add(self, num): # 객체 생성 후 사용할 수 있는 함수.
        self.result += num
        return self.result
    
cal1 = Calculator()
cal2 = Calculator()

print('class1 -> ', cal1.add(3), cal1.add(4))
print('class2 -> ', cal2.add(3), cal2.add(7))

 

********************
FUNCTION
********************
function1 ->  3 7
function2 ->  3 10


********************
CLASS
********************
class1 ->  3 7
class2 ->  3 10