파이토치 프레임워크

파이토치

PyTorch는 파이썬 기반의 오픈소스 딥러닝 프레임워크로, 파이썬 코드로 AI 모델을 직관적으로 만들고 학습할 수 있도록 도와주는 도구입니다. 특히 동적 계산 그래프 방식을 사용하기 때문에 코드 실행 시점에 실시간으로 계산 흐름이 결정되어 디버깅과 수정이 쉽고, GPU 가속과 자동 미분 기능을 통해 대규모 모델도 빠르게 학습할 수 있습니다.

 

동적 계산 그래프 방식

딥러닝 모델이 학습 및 예측을 수행할 때 계산 그래프를 실행 시점(runtime)에 실시간으로 생성 및 수정하는 방식입니다. 이 방식은 조건문, 반복문 등 복잡한 논리 구조를 유연하게 처리할 수 있으며, 주로 PyTorch와 같은 프레임워크에서 사용됩니다. 계산 그래프는 입력 데이터를 바탕으로 연산을 수행하면서 그래프를 생성하고, 역전파를 통해 미분을 계산하며, 최종적으로 가중치를 업데이트하는 과정을 거칩니다. 이러한 특성 덕분에 디버깅이 용이하고 연구 및 개발 속도가 빠르며 직관적인 코드 작성이 가능합니다.

 

스칼라

스칼라(Scalar)는 단 하나의 숫자(정수, 실수 등)만을 담는 자료형을 말합니다. 파이토치(PyTorch)에서 스칼라는 0차원 텐서(0-dimensional Tensor)로 표현합니다. 즉, 텐서의 차원(Shape)이 전혀 없는 상태를 의미합니다.

 

import torch

먼저 파이토치를 사용하기 위해 import 해줍니다

var1 = torch.tensor(5)
print(var1)
print(var1.shape)#0차원 텐서
var2 = torch.tensor([10])
print(var2.shape)#1차원 텐서 1차원 텐서. 스칼라가 아님 벡터임

#실행결과
tensor(5)
torch.Size([])
torch.Size([1])

파이토치를 사용해서 값을 만들어 낼때는 텐서를 생성해서 연산을 합니다

해서 torch.tensor(5)로 텐서를 생성한 후 print  문을 통해 확인해 봅시다.

print(var1) 을 하면 tensor(5)가 출력됩니다 그냥 5가 나오는게 아니라 tensor에 감싸져서 나오죠

shape를 확인해 보면 torch.Size([]) 로 나오게 됩니다 0차원인 스칼라 텐서라는 뜻이죠

 

따라서

torch.tensor(5)

이건 0차원(스칼라) 텐서이며 값은 5인걸 만들어 낸거죠

* 스칼라 텐서는 단일 값을 가지며, 배열 형태가 아닙니다.

var2 = torch.tensor([10])
print(var2.shape)#1차원 텐서 1차원 텐서. 스칼라가 아님 벡터임

그렇다면 이 var2는 값이 [10]인 1차원 텐서를 생성하겠다는 거겠죠

shape로 확인하면 torch.Size([1]) 이 출력됩니다

 

스칼라는 위에서 말했듯 단일 값을 가지며 배열 형태가 아니므로 이 var2는 벡터입니다

 

var1과 var2의 차이가 보이네요

 

차원이 차이나는 이 두 값을 연산을 하면 어떻게 될까요?

var3 = torch.tensor(3)
result = var1 + var2
print(result) #차원이 큰 데이터로 계산
result = var1 + var3
print(result)
print(result.item())#파이썬 숫자로 추출함

 

var1 + var2:

• 연산은 *브로드캐스팅(broadcasting)을 따릅니다.
• var1은 0차원 텐서이고, var2는 1차원 텐서이므로 var1이 자동으로 1차원 텐서로 변환되어 연산이 수행됩니다.
• 결과: [5 + 10] = [15] (1차원 텐서).

var1 + var3:

• var1과 var3은 모두 0차원 텐서(스칼라)이므로 그대로 더해집니다.
• 결과: 5 + 3 = 8 (0차원 텐서).

result.item():

• 0차원 텐서의 값을 Python 숫자(int, float 등)로 추출합니다.
• 주의: item()은 0차원 텐서에서만 사용할 수 있습니다. 1차원 이상 텐서에서 호출하면 오류가 발생합니다.

tensor([15])
tensor(8)
8

 

 

정리

1. 차원 이해:
   • var1: 0차원 텐서 (스칼라). shape은 [].
   • var2: 1차원 텐서 (벡터). shape은 [1].
2. 브로드캐스팅:
   • 연산 시 텐서 간 차원이 맞지 않으면 PyTorch가 자동으로 차원을 맞춥니다. *작은차원 -> 큰 차원
   • 예: 0차원 텐서와 1차원 텐서의 연산 → 0차원 텐서를 1차원으로 변환.
3. 텐서와 Python 숫자 변환:
   • .item(): 0차원 텐서를 Python 숫자로 변환.

벡터(Vector)

벡터(Vector)는 하나 이상의 원소가 일렬로 나열된 1차원 텐서(1D Tensor)를 의미합니다. 파이토치(PyTorch)에서 벡터는 일반적으로 torch.tensor([...]) 형태로 만들며, 이때 텐서의 shape(차원)가 (n,) 형태입니다. 즉, 원소가 n개 들어 있으면 1차원 벡터가 됩니다.

 

1. 텐서 생성

var1 = torch.tensor([1.0, 2.0, 3.0])
print(var1)  # 출력: tensor([1., 2., 3.])
print(var1.shape)  # 출력: torch.Size([3])

torch.tensor([1.0, 2.0, 3.0]):

• 1차원 텐서를 생성합니다.
• 텐서의 값은 [1.0, 2.0, 3.0]이고, 자료형(dtype)은 기본적으로 float32입니다.
• shape은 [3]으로, 요소가 3개인 1차원 텐서를 나타냅니다.

2. 텐서와 스칼라 값의 연산

var2 = var1 + 10
print(var2)  # 출력: tensor([11., 12., 13.])

var1 + 10:

• 텐서 var1과 스칼라 값 10의 합.
• 브로드캐스팅(Broadcasting) 규칙에 따라 스칼라 값 10이 텐서의 각 요소에 더해집니다.
• 결과: [1.0 + 10, 2.0 + 10, 3.0 + 10] = [11.0, 12.0, 13.0].

var3 = var1 * 2
print(var3)  # 출력: tensor([2., 4., 6.])

var1 * 2:

• 텐서 var1의 각 요소에 스칼라 값 2를 곱합니다.
• 결과: [1.0 * 2, 2.0 * 2, 3.0 * 2] = [2.0, 4.0, 6.0].

var4 = torch.tensor([4.0, 5.0, 6.0])
result = var1 + var4
print(result)  # 출력: tensor([5., 7., 9.])

var1 + var4:

• 두 1차원 텐서 var1과 var4의 요소별(element-wise) 합을 계산합니다.
• 각 요소를 위치별로 더합니다:
  • 1.0 + 4.0 = 5.0
  • 2.0 + 5.0 = 7.0
  • 3.0 + 6.0 = 9.0
• 결과: [5.0, 7.0, 9.0].

정리

1. 텐서의 차원 및 형태:
   • var1과 var4는 1차원 텐서로, shape은 [3]입니다.
   • 1차원 텐서는 벡터와 유사한 구조로, 연산 시 동일한 길이여야 합니다.
2. 스칼라 값과 텐서 연산:
   • 스칼라 값은 브로드캐스팅 규칙에 따라 텐서의 각 요소에 적용됩니다.
3. 텐서 간 연산:
   • 동일한 차원과 크기를 가진 텐서 간에는 요소별(element-wise) 연산이 수행됩니다.

 행렬

행렬(Matrix)은 2차원 형태의 텐서로, 파이토치(PyTorch)에서는 shape가 (m, n)처럼 2개의 차원을 가진 텐서를 의미합니다. 예를 들어, torch.tensor([[1, 2], [3, 4]])는 2행×2열 형태의 행렬입니다. 행렬 연산에서는 행렬 곱셈, 원소별 연산, 전치(Transpose) 등이 자주 활용되며, 파이토치는 torch.mm 또는 @ 연산자를 통해 행렬 곱셈을 수행할 수 있습니다.

 

1. 텐서 생성

var1 = torch.tensor([[1, 2],
                     [3, 4]])
var2 = torch.tensor([[5, 6],
                     [7, 8]])
print(var1)  # 출력: tensor([[1, 2], [3, 4]])
print(var1.shape)  # 출력: torch.Size([2, 2])

• torch.tensor([[1, 2], [3, 4]]):
  • 2차원 텐서(행렬)를 생성합니다.
  • var1의 값은:

    [[1, 2],
     [3, 4]]

  • shape은 [2, 2]으로, 2개의 행(row)과 2개의 열(column)을 가진 2차원 텐서입니다.

2. 요소별 연산 (Element-wise Operations)

(1) 덧셈

result1 = var1 + var2
print(result1)  # 출력: tensor([[ 6,  8], [10, 12]])

var1 + var2:

• 두 텐서의 각 요소를 동일한 위치에서 더합니다.
• 계산 과정:

  [[1+5, 2+6],    =>    [[6, 8],
   [3+7, 4+8]]           [10, 12]]

(2) 곱셈

result2 = var1 * var2
print(result2)  # 출력: tensor([[ 5, 12], [21, 32]])

var1 * var2:

• 두 텐서의 각 요소를 동일한 위치에서 곱합니다.
• 계산 과정:

  [[1*5, 2*6],    =>    [[5, 12],
   [3*7, 4*8]]           [21, 32]]

  
  
   

3. 행렬 곱 (Matrix Multiplication)

(1) torch.mm 함수 사용

result3 = torch.mm(var1, var2)
print(result3)  # 출력: tensor([[19, 22], [43, 50]])

torch.mm(var1, var2):

• torch.mm는 **행렬 곱(Matrix Multiplication)**을 수행합니다.
• 행렬 곱은 다음 규칙에 따라 계산됩니다:
  • **첫 번째 행렬의 행(row)**와 두 번째 행렬의 열(column) 간의 내적(dot product).
• 계산 과정:

  [[(1*5 + 2*7), (1*6 + 2*8)],    =>    [[19, 22],
   [(3*5 + 4*7), (3*6 + 4*8)]]           [43, 50]]

(2) @ 연산자 사용

result4 = var1 @ var2
print(result4)  # 출력: tensor([[19, 22], [43, 50]])

var1 @ var2:

• @ 연산자는 torch.mm와 동일하게 행렬 곱을 수행합니다.
• 결과는 torch.mm(var1, var2)와 동일합니다

[[19, 22],
 [43, 50]]

 

정리

1. 텐서의 차원:
   • var1과 var2는 모두 [2, 2]의 2차원 텐서(행렬)입니다.
2. 요소별 연산:
   • +: 동일 위치 요소를 더함.
   • *: 동일 위치 요소를 곱함.
3. 행렬 곱:
   • torch.mm와 @는 동일한 행렬 곱을 수행.
   • 행렬 곱의 규칙:
     • 첫 번째 행렬의 열 수와 두 번째 행렬의 행 수가 같아야 연산 가능.

다차원 텐서

파이토치(PyTorch)에서 다차원 텐서란, 여러 축(차원)을 가지는 텐서를 의미합니다. 예를 들어, 0차원 텐서는 “스칼라(Scalar)”, 1차원 텐서는 “벡터(Vector)”, 2차원 텐서는 “행렬(Matrix)”, 그 이상의 3차원, 4차원 텐서 등을 통틀어 “다차원 텐서(Multi-dimensional Tensor)”라고 부릅니다. 다차원 텐서는 이미지, 음성, 동영상, 시계열 데이터를 비롯하여 여러 축을 필요로 하는 다양한 형태의 데이터를 표현할 때 쓰입니다.

 

1. 텐서 생성

var1 = torch.tensor([
    [[1, 2],
     [3, 4]],

    [[5, 6],
     [7, 8]]
])
print(var1)

torch.tensor([...]):

• 3차원 텐서를 생성합니다.
• 텐서 var1의 값은 다음과 같이 구성됩니다

[
    [[1, 2],    # 첫 번째 "슬라이스"
     [3, 4]],

    [[5, 6],    # 두 번째 "슬라이스"
     [7, 8]]
]

• 구조적으로 보면 두 개의 2x2 행렬로 이루어진 텐서입니다.

2. 텐서의 차원 확인

print(var1.shape)  # 출력: torch.Size([2, 2, 2])

ar1.shape:

• 텐서의 차원을 나타냅니다.
• 출력값 torch.Size([2, 2, 2])의 의미:
  1. 첫 번째 차원: 2개의 "슬라이스"가 존재.
  2. 두 번째 차원: 각 슬라이스는 2개의 행(row)을 가짐.
  3. 세 번째 차원: 각 행(row)은 2개의 열(column)을 가짐.

텐서 구조 이해

3차원 텐서

• 3차원 텐서는 여러 **행렬(2차원 텐서)**이 겹쳐진 형태로 이해할 수 있습니다.
• var1의 구조를 시각적으로 표현하면:
   

"슬라이스 1"
[[1, 2],
 [3, 4]]

"슬라이스 2"
[[5, 6],
 [7, 8]]

차원의 의미

• PyTorch에서 텐서의 차원은 일반적으로 다음과 같이 해석됩니다:
  1. 첫 번째 차원 (Batch): 데이터 그룹(예: 이미지 데이터셋의 여러 이미지).
  2. 두 번째 차원 (Height): 행(row)의 개수.
  3. 세 번째 차원 (Width): 열(column)의 개수.

주의: OpenCV와의 차이

• OpenCV에서는 데이터의 순서가 열-행-채널(Width-Height-Channel) 순서일 수 있습니다.
• PyTorch의 기본 순서는 Batch-Height-Width 또는 채널-행-열(Channel-Height-Width)입니다.

응용

텐서 차원 재구성:

• PyTorch에서는 텐서 차원을 변환할 때 reshape 또는 permute를 사용할 수 있습니다.

reshaped_var1 = var1.reshape(4, 2)  # 3차원 → 2차원으로 변환
permuted_var1 = var1.permute(1, 2, 0)  # 차원 순서 변경

다차원 데이터 활용:

• 이미지 처리: (Batch, Height, Width) 구조로 사용.
• 시계열 데이터: (Batch, Time, Feature) 구조로 사용.

추가 설명

• 3차원 텐서의 사용 사례:
  • 이미지 데이터:
    • 흑백 이미지: (Batch, Height, Width) 또는 (Height, Width).
    • 컬러 이미지: (Batch, Channels, Height, Width).
  • 시계열 데이터:
    • (Batch, Time Steps, Features).
• 3차원 텐서 조작:
  • 특정 슬라이스 추출:

    slice1 = var1[0]  # 첫 번째 슬라이스([[1, 2], [3, 4]])

  • 특정 요소 접근:

    element = var1[1, 0, 1]  # 두 번째 슬라이스의 첫 번째 행, 두 번째 열(값: 6)

• OpenCV와의 차이 해결:
  • 데이터 순서가 다를 경우 permute를 사용하여 PyTorch 텐서를 OpenCV 형식으로 변환하거나 그 반대로 변환할 수 있습니다:

    var1_permuted = var1.permute(2, 1, 0)  # 차원 순서 변경