이진 분류 알고리즘 & 배치(Batch)
테스트 데이터 표준화 및 변환, 이진 분류, 배치(Batch), 가능도, 이진 교차 엔트로피테스트 데이터# 테스트 데이터를 입력받아 예측된 연봉을 반환하는 함수의 코드 표현def predict_test_data(test_data) # 테스트 데이터 표준화 # scaler_x.transform(argument) -> argument를 표준화하는 역할 test_scaled = scaler_x.transform(test_data.reshape(-1, 1)) # reshape(-1, 1) -> 열을 1, 행이 나머지 #표준화한 테스트 데이터를 PyTorch Tensor로 변환 test_tensor = torch.tensor(test_scaled, dtype=torch.float3..
2025.01.03
Tensor 연산 방식
🔑 in-place 방식 연산, Tensor 산술 연산, L1 노름, L2 노름, L∞ 노름, 맨해튼 유사도, 유클리드 유사도, 코사인 유사도, 내적in-place 방식의 연산의 특징in-place 방식은 메모리를 절약하며 Tensor의 값을 업데이트할 수 있는 연산추가적인 메모리 할당이 필요 없기 때문에 메모리 사용량을 줄일 수 있다는 장점이 있지만, autograd와의 호환성 측면에서 문제를 일으킬 수 있음(예시) a.add_(b) f.sub_(e)Tensor 산술 연산더하기/빼기 연산크기가 동일한 두 Tensor의 더하기(빼기) 연산은 각 요소들을 더한(뺀) 값으로 출력크기가 다른 두 Tensor를 계산할 땐 크기가 더 큰 Tensor로 크기를 확장하여 요소들을 연산# Tensor 더하기 연산to..
2025.01.03
Tensor 생성 및 변환
🔑 Tensor 생성 및 변환, CPU와 CUDA(GPU), Tensor 인덱싱, Tensor 슬라이싱, Tensor 모양 변경, reshape() vs view()Tensor 생성 및 변환Tensor 초기화torch.zeros(n)길이가 n인 0으로 초기화된 1-D Tensor를 생성torch.zeros([n,m])크기가 n * m인 0으로 초기화된 2-D Tensor를 생성torch.ones(n)길이가 n인 1으로 초기화된 1-D Tensor를 생성torch.zeros_like(e)e와 크기와 자료형이 같은 0으로 초기화된 Tensor로 변환torch.ones_like(b)b와 크기와 자료형이 같은 1로 초기화된 Tensor로 변환torch.rand(n)크기가 n인, 0~1 사이의 연속균등분포에서 ..
2025.01.02
PyTorch & Tensor
🔑 PyTorch, Tensor, PyTorch 데이터 타입, Tensor 함수, Tensor 메서드PyTorchPyTorch는 간편한 딥러닝 API를 제공하며, 머신러닝 알고리즘을 구현하고 실행하기 위한 확장성이 뛰어난 멀티플랫폼 프로그래밍 인터페이스(Raschka, Liu & Mirjalili, 2022)PyTorch는 Windows, macOS, Linux 등 다양한 환경에서 사용 가능하며 Python, C++, Java 언어를 지원API의 간편성과 Pythonic 특징 때문에 사용성이 좋다PyTorch GitHub, PyTorch Tutorials 등 활발한 커뮤니티와 생태계가 구축되어 있음연산 속도와 효율성이 뛰어나며 GPU를 지원함API란? API(Application Programmin..
2025.01.02

테스트 데이터 표준화 및 변환, 이진 분류, 배치(Batch), 가능도, 이진 교차 엔트로피




테스트 데이터

# 테스트 데이터를 입력받아 예측된 연봉을 반환하는 함수의 코드 표현
def predict_test_data(test_data)

    # 테스트 데이터 표준화
    # scaler_x.transform(argument) -> argument를 표준화하는 역할
    test_scaled = scaler_x.transform(test_data.reshape(-1, 1))
    # reshape(-1, 1) -> 열을 1, 행이 나머지

    #표준화한 테스트 데이터를 PyTorch Tensor로 변환
    test_tensor = torch.tensor(test_scaled, dtype=torch.float32).view(-1, 1).to(device)

    model.eval() #모델을 평가 모드로 전환
    with torch.no_grad(): #그래디언트 계산을 비활성화 -> 메모리 사용을 줄이고 예측 속도를 높이는 역할
        predictions_scaled = model(test_tensor) #모델을 사용해 표준화된 예측 수행

    #예측된 결과의 표준화를 해제하는 코드 표현
    predictions = scaler_t.inverse_transform(predictions_scaled.cpu().numpy())
    #scaler_t.inverse_transform() -> 예측된 값을 원래의 scale로 되돌리는 코드
    #predictions_scaled.cpu().numpy() -> GPU에서 연산한 값이라면 다시 CPU로 이동

    return predictions

no_grad() 의 역할은?

학습을 시킨다는 것 → 최적의 매개변수(w, b)를 찾는 것




이진 분류 모델

특징 변수와 목표 변수 사이의 관계를 학습

단, 목표 변수가 두 가지 범주를 가진다!

(ex) 이메일 스팸 분류 → 스팸 메일 / 스팸이 아닌 메일

#트레이닝 데이터를 불러오는 코드 표현
df = pd.read_csv(“Iris.csv”, sep = “,”, header = 0)[[“PetalLengthCm”, “Species”]]

#Iris_data 데이터 프레임에서 Species 열의 값이 Iris-setosa 
#또는 Iris-versicolor인 행을 필터링하여, filtered_data라는 새로운 데이터 프레임을 생성하는 코드 표현
filtered_data = df[df[‘Species’].isin([‘Iris_setosa’, ‘Iris-versicolor’])]

#Iris_data 데이터 프레임에서 ‘Species’을 선택하는 코드 표현
df[‘Species’].isin([‘Iris_setosa’, ‘Iris-versicolor’])
#Species 열의 각 값이 Iris-setosa 또는 Iris-versicolor와 일치하면 True, 그렇지 않으면 ‘False’를가지는 Boolean Series 코드 표현

데이터 분할

#트레이닝 데이터와 테스트 데이터를 분할하기 위해
#sklearn.model_selection 모듈에서 train_test_split 함수를 임포트
from sklearn.model_selection import train_test_split

#특징 변수 x와 목표 변수 t를 섞어서 학습용 데이터와 테스트용 데이터 분할하는 코드
train_test_split(x, t, test_size = 0.2, random_state = 42)
#test_size = 0.2 -> 8:2로 나눈다는 의미
#ramdom_state(난수 시드) = 42는 관습적인 수 -> 어떤 정수를 사용해도 사실 무방하다

데이터 표준화 모델

from sklearn.preprocessing import StandardScaler

#StandardScaler 객체를 생성해서 scaler에 할당하여 표준화하는 코드 표현
scaler = StandardScaler()

# 트레이닝 데이터의 특징 변수 x를 fit 단계에서 통계량(statistic)을 계산하고 transform 단계에서
# 데이터를 표준화하는 코드 표현
x_train = scaler.fit_transform(x_train)

#테스트 데이터의 특징 변수를 표준화하는 코드 표현
x_test = scaler.transform(x_test)




데이터를 Tensor로 변환할 때 주의점

x_train = torch.tensor(x_train, dtype = torch.float32)
t_train = torch.tensor(t_train, dtype = torch.float32).unsqueeze(1)

t_train(목표 변수)을 unsqueeze 함수를 사용해서 2차원으로 변환하는 이유?

  • 배치 처리를 위해서는 목표 변수의 형태가 [N, 1]이 되어야 함
  • 특징 변수(x)는 [데이터 수, 특징 수]이기 때문에 이미 2차원이며, 일관된 데이터 형태를
    위해 목표 변수 또한 2차원 Tensor로 변환
  • 손실 함수 또한 2차원 Tensor 형태를 기대하므로 호환성을 위해 2차원 Tensor로 변환




Batch(배치)란?

미니 배치 경사하강법

PyTorch 프레임워크에서 Dataset과 DataLoader 클래스를 가지고 오는 코드 표현

from torch.utils.data import DataLoader, TensorDataset

Batch Size는 보통 2의 n승으로 지정하는데, 본인의 GPU의 VRAM 용량에 따라 Out of memory가 발생하지 않도록 정해줘야 한다.

또한, 가능하면 학습데이터 갯수에 나누어 떨어지도록 지정하는 것이 좋은데, 마지막 남은 배치가 다른 사이즈이면 해당 배치의 데이터가 학습에 더 큰 비중을 갖게 되기 때문이다.

예를 들어, 530 개의 데이터를 100개의 배치로 나누면, 각 배치 속 데이터는 1/100 만큼의 영향력을 갖게 된다. 그러나 마지막 배치(30개)의 데이터는 1/30의 영향력을 갖게 되어 과평가되는 경향이 있다. 그렇기 때문에 보통 마지막 배치의 사이즈가 다를 경우 이는 버리는 방법을 사용한다.




이진 분류 알고리즘

로지스틱 회귀 알고리즘

  • 시그모이드 함수

$$
y = Sigmoid(z) = \frac{1}{1 + exp(-z)}
$$




이진 교차 엔트로피

  • 시그모이드 함수에 의해 계산된 0과 1 사이의 값을 가지는 y
  • 정답(실제 레이블) $t_{i}$ = 0 or 1 과의 오차를 바탕으로 표현된 함수식

$$
E(w,b)=-\Sigma_{i=1}^{n}[{t_{i}logy_{i} + (1-t_{i})log(1-y_{i})}]
$$

n = 데이터 샘플의 수

$y_{i}$ = 모델의 객체 값인 0과 1 사이의 확률 값

log = 자연 로그


조건부 확률

  • 사건 A가 발생한 상황 하에서 다른 사건 B가 발생할 확률을 의미

최대 가능도 추정 (MLE)

  • 특정 데이터셋이 있을 때 이 데이터셋을 가장 잘 설명할 수 있는 파라미터 → 모수 찾기
  • 모수 = 모집단으로부터 얻을 수 있는 통계치, 모집단을 대표하는 값
  • 이 모수를 찾기 위해 가능도(likelihood) 함수를 최대화 하는 과정
  • 실제로 계산된 구체적인 모수 값 = 최대 가능도 추정치(Maximum Likelihood Estimate)

가능도

주어진 데이터가 특정 모수 값 하에서 관찰될 확률

$$
L(\Theta;x_{0}=1)=P(x_{0} = 1|\Theta)
$$

$x_{0}$가 1인 데이터가 주어졌을 때 𝜃의 가능도 = 𝜃가 주어졌을 때 $x_{0}$가 1일 확률

  • 가능도 함수가 최대값이 되어야 하는 이유는 최대 가능도 추정의 목표가 주어진 데이터에 가장 적합한 모수를 찾는 것이기 때문
  • 가능도 함수의 최대값을 찾는 방법 = 미분계수가 0이 되는 지점을 찾는 것.

즉, 찾고자 하는 𝜃에 대하여 로그를 취한 로그 가능도 함수를 편미분하고 그 값이 0이 되도록 하는
𝜃를 찾는 과정을 통해 가능도 함수를 최대화 시켜줄 수 있는 𝜃를 찾을 수 있음


이진 분류 테스트

#t_test 텐서를 넘파이 배열로 변환하는 코드 표현
actual_labels = t_test.numpy() **#시각화 및 비교를 하기 위함**

#predicted_labels 텐서를 넘파이 배열로 변환하는 코드 표현
predicted_labels = predicted_labels.numpy()

#predicted_labels을 1차원 배열로 출력하는 코드 표현
print(“Predictions:”, predicted_labels.flatten())

#actual_labels을 1차원 배열로 출력하는 코드 표현
print(“Actual Labels:”, actual_labels.flatten())



'Study - AI > Torch & Tensor' 카테고리의 다른 글

Tensor 연산 방식  (0) 2025.01.03
Tensor 생성 및 변환  (0) 2025.01.02
PyTorch & Tensor  (0) 2025.01.02



in-place 방식의 연산의 특징

  • in-place 방식은 메모리를 절약하며 Tensor의 값을 업데이트할 수 있는 연산
  • 추가적인 메모리 할당이 필요 없기 때문에 메모리 사용량을 줄일 수 있다는 장점이 있지만, autograd와의 호환성 측면에서 문제를 일으킬 수 있음

(예시) a.add_(b) f.sub_(e)




Tensor 산술 연산

더하기/빼기 연산

  • 크기가 동일한 두 Tensor의 더하기(빼기) 연산은 각 요소들을 더한(뺀) 값으로 출력
  • 크기가 다른 두 Tensor를 계산할 땐 크기가 더 큰 Tensor로 크기를 확장하여 요소들을 연산
# Tensor 더하기 연산
torch.add(a, b)

# in-place 방식의 더하기 연산
a.add_(b)

# Tensor 빼기 연산
torch.sub(f, e)

# in-place 방식의 빼기 연산
f.sub_(e)

스칼라곱 연산

  • 스칼라곱은 Tensor의 각 요소에 동일한 스칼라 값을 곱하는 연산을 의미
# 스칼라 i와 Tensor j를 스칼라곱
torch.mul(i, j)

요소별 곱셈(Hadamard product, Element wise product)/나눗셈 연산

  • 크기가 동일한 두 Tensor의 요소별 곱셈/나눗셈 연산은 각 요소들을 곱한(나눈) 값으로 출력
  • 크기가 다른 두 Tensor를 연산할 땐 크기가 더 큰 Tensor로 크기를 확장하여 요소들을 연산
# Tensor 요소별 곱셈
torch.mul(k, l)

# in-place 방식의 요소별 곱셈
k.mul_(l)

# Tensor 요소별 나눗셈
torch.div(o, p)

# in-place 방식의 요소별 나눗셈
o.div_(p)

비교 연산

  • Tensor의 요소들이 비교
  • 결과는 Boolean Tensor로 출력
# 요소들이 같은지 비교
torch.eq(v, w) #equal

# 요소들이 다른지 비교
torch.ne(v, w) #not equal

# v의 요소들이 w의 대응요소들보다 큰지 비교
torch.gt(v, w) #greater than

# v의 요소들이 w의 대응요소들보다 크거나 같은지 비교
torch.ge(v, w) #greater than or equal

# v의 요소들이 w의 대응요소들보다 작은지 비교
torch.lt(v, w) #less than

# v의 요소들이 w의 대응요소들보다 작거나 같은지 비교
torch.le(v, w) #less than or equal




Tensor 논리 연산

  • 논리곱(AND), 논리합(OR), 배타적 논리합(XOR)
# 논리곱(AND) 연산
# 입력된 신호가 모두 참일 때, 출력이 참이 되는 연산
torch.logical_and(x, y)

# 논리합(OR) 연산
# 입력된 신호 중 하나라도 참일 때, 출력이 참이 되는 연산
torch.logical_or(x, y)

# 배타적 논리합(XOR) 연산
# 입력된 신호가 하나만 참일 때, 출력이 참이 되는 연산
torch.logical_xor(x, y)




Tensor의 노름(Norm)

Ln 노름(Norm)

  • 1-D Tensor의 노름은 Vector가 원점에서 얼마나 떨어져 있는지를 의미함
  • 1-D Tensor의 노름은 Vector의 길이를 측정하는 방법으로 사용됨
  • 1-D Tensor의 노름에는 L1 노름, L2 노름, L∞ 노름 등 여러가지 유형의 노름이 존재함
  • 참고 자료

노름, 놈, 벡터의 길이, 벡터의 크기

Lp 노름에 대한 수학적 정의 - The p-norm in finite dimensions


L1 노름

  • L1 노름은 1-D Tensor에 포함된 요소의 절대값의 합으로 정의할 수 있음
  • L1 노름은 맨해튼 노름이라고도 불리며, 일차원 텐서에 포함된 요소의 절대값의 합으로 정의 가능
  • torch.norm(a, p=1)

L2 노름

  • L2 노름은 일차원 텐서에 포함된 요소의 제곱합의 제곱근으로 정의할 수 있음
  • 유클리드 공간에서 두 점 사이의 최단 거리를 측정하는 방법과 같다고 해서 유클리드 노름이라고 부름
  • torch.norm(a, p=2)

L∞ 노름

  • L∞ 노름은 일차원 텐서에 포함된 요소의 절대값 중 최대값으로 정의
  • torch.norm(a, p = float(‘inf’))




유사도 (Similarity)

유사도

  • 두 1-D Tensor(=Vector)가 얼마나 유사한지에 대한 측정값을 의미
  • 군집화(Clustering) 알고리즘에서 데이터들이 얼마나 유사한지를 판단하는
    중요한 기준으로 사용됨

맨해튼 유사도

  • 두 1-D Tensor 사이의 맨해튼 거리를 역수로 변환하여 계산한 값
  • 두 1-D Tensor 사이의 맨해튼 거리의 값이 작아질 수록 맨해튼 유사도의 값은 커짐
  • 맨해튼 유사도의 값은 1에 가까울수록 두 Tensor가 유사하다고 판단함
  • 맨해튼 거리 manhattan_distance = torch.norm(b – c, p = 1)
  • 맨해튼 유사도 1 / (1 + manhattan_distance)

유클리드 유사도

  • 두 1-D Tensor 사이의 유클리드 거리를 역수로 변환하여 계산한 값
  • 두 1-D Tensor 사이의 유클리드 거리의 값이 작아질수록 유클리드 유사도의 값은 커짐
  • 유클리드 유사도의 값은 1에 가까울수록 두 Tensor가 유사하다고 판단함
  • 유클리드 거리 euclidean_distance = torch.norm(b – c, p = 2)
  • 유클리드 유사도 1 / (1 + euclidean_distance)

코사인 유사도

  • 두 1-D Tensor 사이의 각도를 측정하여 계산한 값

  • 내적의 정규화?

  • 각도를 측정하여 두 Tensor의 유사도를 판단하기 때문에 코사인 유사도의 값이 1에 가까울 수록 두 Tensor가 유사하다고 판단함

    → 코사인 함수에서 라디안 값이 0일 때 함수의 값이 1이 되기 때문에 코사인 유사도의 값이 1에 가까울수록 두 텐서가 유사하다고 판단

  • 1-D Tensor(=Vector)의 내적(dot product 또는 inner product)을 활용하여 두 1-D Tensor 사이의 각도를 측정

  • cosine_similarity = torch.dot(b, c) / (torch.norm(b, p = 2) * (torch.norm(c, p = 2))




내적 (Inner Product)

  • 도트곱(Dot Product), 스칼라적(Scalar Product)로도 불림
  • 두 개의 벡터를 입력으로 취하고, 스칼라 값(길이, 거리 등의 단일 숫자)을 결과로 출력하는 연산
  • 두 벡터 간의 기하학적인 비교(특징, 유사성)에 대한 단일값으로 사용됨
  • 일반적으로 벡터의 같은 성분끼리 각각 곱하여 모두 합하는 방식으로 구할 수 있음

1-D Tensor의 내적

  • 두 1-D Tensor 사이의 관계를 하나의 0-D Tensor(=Scalar)로 변환하는 것으로, 이러한 변환은 두 1-DTensor의 유사성을 수량화할 수 있는 장점을 가짐
  • 일차원 텐서의 내적은 두 일차원 텐서 사이의 관계를 하나의 스칼라(0차원 텐서)로 변환하는 것으로, 이 변환을 통해 두 일차원 텐서 사이의 유사성을 수량화 할 수 있음
  • 1-D Tensor의 내적을 구하는 방법
  1. 두 1-D Tensor의 각 요소를 곱해서 더하는 방법 (일반적으로 사용되는 방법)
  2. 두 1-D Tensor의 길이를 곱하는 방법 (일차원 텐서의 내적을 활용해서 두 텐서 사이의 각도를 측정하는 것의 핵심)




2-D Tensor의 행렬 곱셈 연산

  • 2-D Tensor(=Matrix)의 행렬 곱셈은 두 행렬을 결합하여 새로운 행렬을 생성하는 연산
  • 2-D Tensor의 행렬 곱셈은 신경망 구현에 핵심이 되는 연산임
# Tensor D와 Tensor E의 행렬 곱셈 연산
D.matmul(E)
D.mm(E)
D @ E

torch.dot

  • 벡터의 내적만 지원. (numpy와는 다르게 행렬곱/행렬연산은 지원하지 않는다.)

torch.matmul

  • vector의 내적, 행렬의 연산 다 사용가능
  • broadcasting을 지원한다. (debugging에서 불리한 포인트)

torch.mm

  • 행렬의 곱셈만 지원. vector의 내적 불가능.
  • broadcasting을 지원하지 않는다. → Debug에서 유리하다.
  • 추가적으로, batch 차원까지 연산을 지원해주지는 않는다. 딱, 2차원 행렬끼리의 곱만 연산가능하다.
    • ex. (3, 4) @ (4, 10) = (3, 10)

torch.bmm

  • torch.mm과의 차이점은 mm은 2차원 행렬의 곱 연산만 지원하고,torch.bmm은 3차원 텐서의 곱 연산만 지원한다.ex. (10, 5, 3) @ (10, 3, 2) = (10, 5, 2)



'Study - AI > Torch & Tensor' 카테고리의 다른 글

이진 분류 알고리즘 & 배치(Batch)  (0) 2025.01.03
Tensor 생성 및 변환  (0) 2025.01.02
PyTorch & Tensor  (0) 2025.01.02

Tensor 생성 및 변환

Tensor 초기화

torch.zeros(n) 길이가 n인 0으로 초기화된 1-D Tensor를 생성
torch.zeros([n,m]) 크기가 n * m인 0으로 초기화된 2-D Tensor를 생성
torch.ones(n) 길이가 n인 1으로 초기화된 1-D Tensor를 생성
torch.zeros_like(e) e와 크기와 자료형이 같은 0으로 초기화된 Tensor로 변환
torch.ones_like(b) b와 크기와 자료형이 같은 1로 초기화된 Tensor로 변환
torch.rand(n) 크기가 n인, 0~1 사이의 연속균등분포에서 추출한 난수로 채워진 Tensor를 생성
torch.randn(n) 크기가 n인, 표준정규분포에서 추출한 난수로 채워진 Tensor를 생성
torch.rand_like(n) n과 크기와 자료형이 같은 [0, 1] 구간의 연속균등분포 난수로 채워진 Tensor로 변환
torch.arange(start, end, step) start에서 end(포함하지 않음)까지 step만큼 증가하는 1-D Tensor

초기화 하지 않은 Tensor

  • 성능 향상: Tensor를 생성하고 곧바로 다른 값들로 덮어쓸 예정인 경우라면, 초기 값을 설정하는 단계는 불필요한 자원을 소모하는 것임
  • 메모리 사용 최적화: 큰 Tensor를 다룰 때, 불필요한 초기화는 메모리 사용량을 증가시킴. 초기화되지 않은 Tensor를 사용함으로써 메모리 할당 후 즉시 필요한 계산에 사용하여 메모리 효율성을 높일 수 있음
torch.empty(n) 크기가 n인 초기화 되지 않은 Tensor를 생성
t.fill_(k) 초기화 되지 않은 Tensor t의 데이터를 k로 수정해 채움. 이때, 메모리 주소는 변경되지 않음!

다양한 Tensor 생성

torch.tensor(리스트) 리스트를 Tensor로 생성할 수 있음
torch.from_Numpy(u)
넘파이 매트릭스 u를 Tensor로 생성
torch.IntTensor(n) n을 데이터로 갖는 정수형 CPU Tensor 생성
torch.FloatTensor(n) n을 데이터로 갖는 실수형 CPU Tensor 생성
torch.ByteTensor 8비트 부호 없는 정수형 CPU Tensor 생성
torch.CharTensor 8비트 부호 있는 정수형 CPU Tensor 생성
torch.ShortTensor 16비트 부호 있는 정수형 CPU Tensor 생성
torch.LongTensor 64비트 부호 있는 정수형 CPU Tensor 생성
torch.DoubleTensor 64비트 부호 있는 실수형 CPU Tensor 생성
y = x.clone() Tensor x와 같은 Tensor y를 생성
z = x.detach() Tensor x와 같은 Tensor z를 생성, clone() 메서드와 다른 점은 x를 계산 그래프에서 분리하여 새로운 Tensor z에 저장한다는 것




CUDA Tensor

CUDA

# Tensor t가 어떤 디바이스(CPU, CUDA...)에 있는지 확인
t.device

#CUDA를 사용할 수 있는 환경인지 확인
torch.cuda.is_available()

#CUDA device 이름을 확인
torch.cuda.get_device_name(device=0)

#Tensor를 GPU에 할당
g = torch.tensor([1, 2, 3, 4, 5]).to(‘cuda’)
g = torch.tensor([1, 2, 3, 4, 5]).cuda()

#GPU에 할당된 Tensor를 CPU Tensor로 변환하는 코드 표현
c = b.to(device = ‘cpu’)
c = b.cpu()




Tensor 인덱싱 / 슬라이싱

  • Indexing(인덱싱)이란 Tensor의 특정 위치의 요소에 접근하는 것
  • Slicing(슬라이싱)이란 Tensor의 부분집합을 선택하여 새로운 Sub Tensor를 생성하는 과정

Tensor의 인덱싱과 슬라이싱은 대부분 numpy와 같은 방식으로 이루어진다!



Tensor 모양 변경: view() vs reshape()

view()

t.view(m, n)
#텐서 t로부터 m*n 크기의 서브 텐서를 생성하는 메서드
  • view() 메서드는 Tensor의 메모리가 연속적으로 할당된 경우에 사용 가능
  • 슬라이싱 등으로 Tensor를 조작했을 때 서브 Tensor가 생성되는 과정에서 메모리가 비연속적으로 변하기도 하기 때문에 확인이 필요함
  • view() 메소드는 연속적인 상황에서 원본과 동일한 데이터를 가리키면서 모양과 같은 메타 정보만 바뀌기 때문에 빠르다
  • view() 메서드 사용 가능 여부는 stride에 영향을 받는다? stride가 규칙성을 가지면 연속적이라 판단하기도 하는 모양.

reshape()

t.reshape(m, n)
#텐서 t로부터 m*n 크기의 서브 텐서를 생성하는 메서드
  • reshape() 메서드는 view() 메서드와 달리 Tensor의 메모리가 연속적으로 할당되지 않아도 사용이 가능
  • 안전하고 유연성이 좋다는 장점이 있으나 성능 저하의 단점이 있음

view() vs reshape()

  • 메모리의 연속성이 확실하고 성능이 중요한 경우 view() 메서드를 사용하는 것이 좋음
  • PyTorch에서 view()를 사용할 수 있는지 확실하지 않은 경우 대부분 reshape()를 사용할 것을 권장하고 있음

메모리 정렬이 이루어지지 않은 데이터는 데이터 참조시 불필요하게 전체 메모리에서 값을 찾아야 할 수 있음.

반대로 메모리 정렬이 잘 되어 있다면 데이터 참조 시에 주소 순서에 따라 빠르게 데이터를 가져올 수 있음. 이 경우 데이터가 커지면 커질 수록 정렬된 데이터연산에도 유리!

또한 Contigous()한 상태로 가져오지 않고 처리할 경우, 나중에 데이터 처리를 위한 정렬을 다시 해야 하므로 비용이 이중으로 발생!




Tensor 모양 변경

flatten()

  • Tensor를 평탄화 하는 모양 변경 방법
  • flatten() 함수는 다차원 데이터를 처리할 때 유용하며, 데이터를 신경망 모델에 적합한 형태로 전처리하기 위해 많이 활용함

# 3차원 텐서 k

l = torch.flatten(k, 0)
# k의 0번째 차원부터 마지막 차원까지 평탄화

m = torch.flaten(k, 1, 2)
# k의 1번째 차원부터 2번째 차원까지 평탄화

transpose()

  • transpose는 Tensor의 특정한 두 차원의 축을 서로 바꿈
q.transpose(0, 1)
# q 텐서의 0차원과 1차원의 축을 바꿈

squeeze()

  • Tensor에서 dim이 1인 특정 차원을 축소
# Tensor w에서 dim이 1인 특정 차원을 축소하는 코드 표현
x = torch.squeeze(w, dim = 0) 
# 또는
x = torch.squeeze(w, dim = 1) 

unsqueeze()

  • Tensor에서 dim이 1인 특정 차원을 확장
#Tensor y에서 2차원으로 dim이 1인 특정 차원을 확장하는 코드 표현
z = torch.unsqueeze(y, dim = 2)

stack()

  • dim-n인 축을 기준으로 새로운 차원을 생성하여 Tensor들을 결합
# dim-0인 축을 생성하여 3개의 2D Tensor를 결합
# argument 안 주면 default가 dim=0
a = torch.stack((red_channel, green_channel, blue_channel))

# dim-1인 축을 생성하여 3개의 2D Tensor를 결합
a = torch.stack((red_channel, green_channel, blue_channel), dim = 1)

cat()

  • 새로운 차원을 추가하는 것이 아닌 기존의 차원을 유지하면서 Tensor들을 연결
  • 기존을 차원을 유지하기 때문에 크기가 맞아야만 연결할 수 있음
# dim = 0을 기준으로 Tensor b와 c를 연결
d = torch.cat((b,c))

# dim = 1을 기준으로 Tensor b와 c를 연결
d = torch.cat((b,c), 1)

expand()

  • 주어진 Tensor의 차원의 크기가 1일 때, 해당 차원의 크기를 확장함
  • 크기가 1인 차원이 있으면 메모리를 할당하지 않고 expand가 일어나고, 그렇지 않으면 할당하면서 expand가 일어난다?
f = torch.tensor([[1, 2, 3]]) # 크기가 (1,3)인 2차원 텐서
g = f.expand(4, 3) 
# (1, 3) 크기인 f를 (4,3)로 확장

repeat()

  • repeat() 메서드는 Tensor의 요소들을 반복해서 크기를 확장하는데 사용하며,expand() 메서드와는 다르게 Tensor의 차원 중 일부의 크기가 1이어야 하는 제약이 없음
  • repeat() 메서드는 추가 메모리를 할당하기 때문에 메모리를 할당하지 않는expand() 메서드보다 메모리 효율성이 떨어짐
  • repeat() 메서드와 expand() 메서드의 차이점 파악할 것
# Tensor h를 dim = 0 축으로 2번 반복하고, dim = 1 축으로 3번 반복하여 크기 확장
i = h.repeat(2, 3)

'Study - AI > Torch & Tensor' 카테고리의 다른 글

이진 분류 알고리즘 & 배치(Batch)  (0) 2025.01.03
Tensor 연산 방식  (0) 2025.01.03
PyTorch & Tensor  (0) 2025.01.02



PyTorch

  • PyTorch는 간편한 딥러닝 API를 제공하며, 머신러닝 알고리즘을 구현하고 실행하기 위한 확장성이 뛰어난 멀티플랫폼 프로그래밍 인터페이스(Raschka, Liu & Mirjalili, 2022)

  • PyTorch는 Windows, macOS, Linux 등 다양한 환경에서 사용 가능하며 Python, C++, Java 언어를 지원

  • API의 간편성과 Pythonic 특징 때문에 사용성이 좋다

  • PyTorch GitHub, PyTorch Tutorials 등 활발한 커뮤니티와 생태계가 구축되어 있음

  • 연산 속도와 효율성이 뛰어나며 GPU를 지원함

  • API란?

    API(Application Programming Interface)란 응용 프로그램이 서로 상호작용하는데 사용하는
    명령어, 함수, 프로토콜의 집합을 의미함



Tensor

  • Tensor는 PyTorch의 핵심 데이터 구조로서, NumPy의 다차원 배열과 유사한 형태로
    데이터를 표현함
# 0-D Tensor(=Scalar)
# 하나의 숫자로 표현되는 양
a = torch.tensor(36.5)

# 1-D Tensor(=Vector)
# 순서가 지정된 여러 개의 숫자들이 일렬로 나열된 구조
b = torch.tensor([175, 60, 81, 0.8, 0.9])

# 2-D Tensor(=Matrix)
# 동일한 크기를 가진 1D Tensor들이 모여서 형성한, 행과 열로 구성된 사각형 구조
# (예시) 그레이 스케일 이미지 : 각 픽셀이 빛의 양을 의미하는 하나의 값을 가짐
c = torch.tensor([[77, 114, 140, 191],
                                        [39, 56,46, 119],
                                        [61, 29, 20, 33]])

# 3-D Tensor
# 동일한 크기의 2-D Tensor들이 여러 개 쌓여 형성된 입체적인 배열 구조
# (예시) 컬러 이미지 : 각 픽셀마다 R/G/B와 대응되는 3개의 요소 값 가짐
# 컬러 이미지는 투명도를 의미하는 A(알파) 채널을 추가할 수도 있음
d = torch.tensor([[[255, 0, 0], 
                                    [0, 255, 0]],
                                        [[0, 0, 255],
                                        [255, 255, 0]]])



PyTorch 데이터 타입

데이터 타입(dtype) 유형 비트 범위 비고
torch.uint8 정수형 8 0~255 정수 부호 없음
torch.int8 정수형 8 -128 ~ 127 정수 부호 있음
torch.int16 또는 torch.short 정수형 16 -32,768 ~ 32,7677 정수
torch.int32 또는 torch.int 정수형 32 -2,147,483,648 ~ 2,147,483,647 정수 표준적인 정수 크기로 사용
torch.int64 또는 torch.long 정수형 64 -9,223,372,036,854,775,808 ~ 9,223,372,036,854,775,807 정수
torch.float32 또torch.float 실수형 32 부호 (1비트) / 지수부 (8비트) / 가수부 (23비트) 32비트 부동 소수점 수
torch.float64 또는 torch.double 실수형 64 부호 (1비트) / 지수부 (11비트) / 가수부 (52비트) 64비트 부동 소수점 수



타입 캐스팅

PyTorch에서 타입 캐스팅은 한 데이터 타입을 다른 데이터 타입으로 변환하는 것

(예시) j = i.float() k = i.double()



Tensor 기초 함수 및 메서드

mIn() Tensor의 모든 요소들 중 최소값을 반환하는 함수
max() Tensor의 모든 요소들 중 최대값을 반환하는 함수
sum() Tensor의 모든 요소들의 합을 계산하는 함수
prod() Tensor의 모든 요소들의 곱을 계산하는 함수
mean() Tensor의 모든 요소들의 평균을 계산하는 함수
var() Tensor의 모든 요소들의 표본분산을 계산하는 함수
std() Tensor의 모든 요소들의 표본표준편차를 계산하는 함수
t.dim() Tensor t의 차원의 수를 확인하는 메서드
t.size() 또는 t.shape() Tensor t의 크기(모양)을 확인하는 메서드 (또는 속성)
t.numel() Tensor t에 있는 요소의 총 개수를 확인하는 메서드



표본분산

표본 : 과학적인 방법으로 모집단에서 추출한 일부 데이터의 집합

모집단 : 연구 또는 조사에서 관심의 대상이 되는 전체 집단을 의미

표본분산

  • 주어진 표본 데이터 집합의 분포 정도를 나타내는 통계량으로, 데이터가 평균값을 중심으로 얼마나 퍼져 있는지를 제곱한 값의 평균으로 계산함
  • 단, 전체 표본의 개수에서 1을 뺐을 때 더 정확한 분산이 도출되므로 수식 표현에서와 같이 1을 뺀
    (n-1)로 계산하며, 이를 자유도라고 함

$$
S^2=\frac{1}{(n-1)}\sum_{i=1}^{n}(x_{i}-\overline{x})^2 (\overline{x}:평균)
$$

표본표준편차 : 표본분산값에 루트를 해서 구할 수 있음

'Study - AI > Torch & Tensor' 카테고리의 다른 글

이진 분류 알고리즘 & 배치(Batch)  (0) 2025.01.03
Tensor 연산 방식  (0) 2025.01.03
Tensor 생성 및 변환  (0) 2025.01.02