• 회귀분석 및 선형회귀분석, 회귀분석 모델 평가지표 (MAE, MSE, RMSE 등)
• Nearest Neighbor Classifier
• kNN, k-Means 알고리즘

Regression 회귀

Regression analysis 회귀 분석

관찰된 연속형 변수들에 대해 두 변수 사이의 모형을 구한 뒤 적합도를 측정하는 분석 방법

• 독립변수(설명변수) : 결과의 원인 (x)
• 종속변수(응답변수) : 독립변수에 따라 값이 달라짐 (y)

Linear Regression 선형 회귀

종속 변수와 하나 이상의 독립 변수 간의 관계를 모델링하는 통계적 방법

→ 독립 변수의 값을 기반으로 종속 변수의 값을 예측하기 위함

• y = mx + b
  • y : 종속변수 (목표)
  • x : 독립변수 (예측 변수)
  • m : 직선의 기울기 (회귀 계수)
  • b : y 절편 (상수항)

Linear Regression의 가정

• 선형성: 종속 변수와 독립 변수 간의 관계가 선형적이어야 한다

• 독립성: 관측값들은 서로 독립적이어야 한다

  • 잔차들이 무작위로 분포되어 있어야 함 → 시간의 흐름에 따라 잔차가 특정 패턴을 보이면 위배

    잔차 Residual

• 등분산성: 오류의 분산이 일정해야 한다

  • 잔차들이 일정한 분포를 보여야 함 → 특정 구간에서 잔차의 분산이 커지거나 작아지면 위배

• 정규성: 오류가 정규 분포를 따른다

  • 잔차들이 정규 분포를 따를 경우 점들이 대각선에 가깝게 위치함

최소 제곱법 OLS, Ordinary Least Squares

• 관측 값과 예측 값의 차이(잔차)의 제곱합을 최소화하는 매개변수 m과 b를 추정하는 방법

다중 선형 회귀

• 여러 독립 변수를 포함하도록 선형 회귀를 확장하여 종속 변수와의 관계를 모델링
  • 종속 변수와 독립 변수 사이의 관계가 선형이라는 가정을 따른다
• 최소 제곱법(OLS)를 사용하여 회귀 계수를 추정할 수 있음
• 독립 변수 간의 다중 공선성(multicollinearity) 문제를 가질 수 있음

(ex) 집 크기(x), 침실 수(x), 집값(y) 간의 관계 → y는 하나, x가 여럿

모델 평가 지표

• 평균 절대 오차 MAE, Mean Absolute Error
  • 예측 값이 실제 값과 얼마나 차이나는지 절대값으로 계산해 평균화한 지표
• 평균 제곱 오차 MSE, Mean Squared Error
  • 실제 값과 예측 값 간의 차이의 제곱을 평균 낸 값. 오차를 제곱하므로 큰 오차에 더 큰 패널티를 부여 → 모델의 큰 오차를 줄이는 데에 유용
  • 단위가 제곱된 형태라 실제 값과 다를 수 있음
• 제곱근 평균 제곱 오차 RMSE, Root Mean Square Error
  • MSE에 제곱근을 취한 값으로, 오차를 원래 단위로 변환. MSE와 같은 장점을 가지면서도 단위 문제를 해결
  • 해석이 용이하고, 큰 오차에 민감하게 반응하는 동시에 실제 값과 같은 단위를 유지
• 결정 계수 $R^{2}$
  • 모델이 종속 변수의 변동성을 얼마나 설명하는지를 나타내는 지표
  • 0에서 1 사이의 값을 가지며, 1에 가까울수록 모델이 데이터를 잘 설명하는 것
  • 모델의 설명력을 평가하는 데에 유용

Nearest Neighbor Classifier

• 쿼리(테스트) 데이터 포인트에 대해 가장 가까운 (k개의) 학습 데이터 포인트를 (k)개 찾고, 레이블을 사용하여 예측

import numpy as np

class NearestNeighbor :
    def __init__ (self) :
        pass

    def train (self, images, labels) :
        # simpLy remembers ail the training data
        self.images = images
        self.labels = labels

    def predict (self, test image) :
        # assume that each image is vectozized to ID
        min_dist = sys.maxint # maximum integer in python
        for i in range(self.images.shape[0]) :
            dist = np.sum(np.abs(self.images[i, :] - test_image))
            if dist < min_dist :
                min_dist = dist
                min_index = i
return self.labels[min_index]

• N개의 훈련 샘플이 있다고 할 때, 훈련 시 O(1), 예측 시 O(N)

Issues

• 픽셀 거리에는 k-nn이 사용되지 않음
• 거리 → Semantic한 정보를 제공하지 않음

k - Nearest Neighbor Classifier

• 가장 가까운 k개 지점에서 과반수 득표를 받아야
• k가 높으면 노이즈를 잡는 데에 유리하다

Linear Classifier

이미지는 기본적으로 3차원 행렬

인풋 이미지랑 똑같은 크기의 각 픽셀에 매핑되는 매개변수 w의 가중치(혹은 파라미터)

편향 bias : 인풋 데이터에게 영향을 받지 않으면서 아웃풋 데이터에 영향을 주는 파라미터

→ 데이터셋이 어떤 데이터에 편향되어 있는지에 대한 지표

f(x, W) = Wx + b → 행렬 곱을 이용하여 f(x, W) = W’x’

‘ 생략 → f(x, W) = Wx

매개변수적 모델의 장점 :

• 학습이 완료되면 가중치 W만을 필요로 함 방대한 학습 데이터 셋을 저장할 필요가 없다
  → 공간 효율성이 높음
• 테스트 시 단일 행렬-벡터 곱(Wx)으로 예제를 평가할 수 있다
  → 모든 훈련 데이터와 비교하는 것보다 훨씬 빠르다

Softmax Classifier

소프트맥스 함수의 수치적 불안정성(numerical instability)을 해결하기 위한 가장 적절한 방법은 무엇일까?

소프트맥스 함수는 입력 값의 지수화를 통해 각 클래스에 속할 확률을 계산한다. 그러나, 지수화를 할 때 큰 수를 다루게 되면 수치적 불안정성이 발생할 수 있다.

이를 방지하기 위해 흔히 사용되는 방법은 입력 값의 최대값을 계산하여 모든 입력 값에서 이를 빼는 것!

이렇게 하면 가장 큰 값이 0이 되어 지수화할 때 수치적으로 안정적인 값을 유지할 수 있다. 이 방법은 소프트맥스 함수의 수치적 안정성을 높이고 오버플로우를 방지하는 데 효과적이다.

Loss Function

이진 분류의 경우, 기준값(ground truth)은 y ={+1,-1}

• 모델은 하나의 점수 ŷ ∈ ℝ 를 예측
• ŷ이 0보다 크면 포지티브 클래스로, 그렇지 않으면 네거티브 클래스로 분류

마진 기반 손실

• 손실은 yŷ에 따라 결정
• 부호가 같으면(즉, 분류가 정확하면) 손실이 작아지거나 0
• 부호가 다르면(잘못된 분류) 손실이 커짐

0/1 손실

• 모델이 예제를 잘못 분류하면 일정한 손실 발생
• 올바르게 분류하면 손실이 없음
• yŷ = 0 일 때 (Step Function) 미분 불가능한 영역이 존재 → 실제로 사용하기 어려움

로그 손실

• 예측이 정확할수록 패널티가 작아진다 (0은 아님)
• 연속 함수 → 어느 지점에서나 미분 가능
• 확률 값으로 아웃풋을 냄 → 사용하기 좋음

지수 손실

• 로그 손실과 비슷하지만 잘못된 경우 더 큰 패널티를 주고 올바른 경우 적은 패널티를 준다
• 어느 지점에서나 미분 가능

Hinge 힌지 손실

• 오류에 대한 패널티가 선형적으로 증가
• 오차 범위 내에서 정답인 경우에도 약간의 패널티
• 미분 값이 항상 상수? → 계산이 효율적

장단점

• 지수 손실은 아웃라이어에 매우 큰 손실을 할당하므로 아웃라이어의 영향을 강하게 받음

  틀린 것에 대해 많은 영향을 받으므로 → 노이즈가 많은 데이터에 적합하지 않음

• 힌지 손실과 로그 손실은 널리 사용

• 힌지 손실(SVM)이 계산적으로 더 효율적

• 로그 손실(로지스틱 회귀)은 출력을 p(y|x)로 볼 수 있기 때문에 해석이 더 쉽다

SVM, Support Vector Machine

로지스틱 회귀

손실 함수 : 확률적 설정

이진 분류 문제에 대하여, 기준값은 y ={0,1}입니다.

• 이 모델은 한 클래스의 확률인 하나의 점수 ŷ를 예측함
• 다른 클래스의 확률은 1-ŷ
• 점수 차이에 시그모이드 함수를 적용하는 것이 그 예시!
  • 자연스럽게 K >2 클래스까지 확장됨
• 기준값은 1열 벡터로 표현됨 -> y=[0,0,0,0,1,0,0].
• 모델은 K - 1 점수를 예측하고 마지막 점수를 ‘1-합계’로 남긴다
• 소프트맥스가 그 예시 -> 예측값이 0에서 1 사이이고 합계가 1
  • 이 설정에서 손실 함수는 기본적으로 두 개의 (GT와 예측)확률 분포를 비교

Cross Entropy

• $y_{ik}$ → i번째 데이터의 k번째 클래스에 대한 정답 값
• $\hat y_{ik}$ → i번째 데이터의 k번째 클래스에 해당하는 예측 값
• {log(예측 값) * 정답 값}를 다 더하고 N(데이터 수)으로 나누고 마이너스

머신 러닝 Machine Learning

인공지능 > 머신러닝 > 딥러닝

위의 크기대로 상위 개념이라고 볼 수 있음

Tom Mitchell의 머신러닝 정의

머신러닝이란 다음과 같은 알고리즘을 연구하는 학문

• 어떠한 작업 T에 대하여
• 경험 E와 함께
• 성능 P를 향상시킨다

제대로 정의된 학습 과제는 <P, T, E>에 의해 주어진다

전통적 프로그래밍

데이터, 프로그램 입력 → 출력값 출력

머신 러닝

데이터, 출력값 입력 → 프로그램 출력

머신 러닝 : 학습의 종류

지도 학습 (귀납적 학습) Supervised Learning

Classification Algorithm

• 학습 데이터 x + 원하는 출력(레이블) y를 페어로 제공 받아 학습을 진행

  → 주어진 x에 대해 y를 예측하는 함수 f(x)를 학습

• y가 실수값 → 회귀(Regression)

• y가 범주형 → 분류(Classification)

  → 주로 회귀 문제에 사용

준지도 학습 Semi-supervised Learning

• 가장 현실적

비지도 학습 Unsupervised Learning

Clustering Algorithm

• 레이블(라벨) 없이 학습 데이터 x만 이용하여 학습 진행

  → 주어진 x 뒤에 숨겨진 구조를 출력

• 주로 클러스터링 같은 군집화 문제에 사용

• 딥러닝에서는 AutoEncoder

자기 지도 학습 Self-supervised Learning

강화 학습 Reinforcement Learning

• 일련의 행동에 따른 보상
• 어떤 환경에서 정의된 에이전트(시스템)가 현재의 상태를 인식하여 선택 가능한 행동들 중 보상을 최대화하는 행동 혹은 행동 순서를 선택하는 방법
• 보상이 있는 상태와 액션의 시퀀스가 주어졌을 때, (지연)보상이 있는 일련의 상태와 작업이 주어지면 policy를 출력 → Policy란 주어진 상태에서 수행해야 할 작업을 알려주는 ‘상태→작업’ 형식의 매핑

머신 러닝 라이프 사이클 Machine Learning Life Cycle

머신 러닝 모델을 개발, 배포, 유지 및 보수하는 일련의 단계들을 정의하는 프로세스

1. 계획하기 (Planning)

• ML 애플리케이션의 범위, 성공 지표 및 실현 가능성을 평가하는 작업 포함
• 비즈니스와 머신러닝을 사용하여 현재 프로세스를 개선하는 방법의 이해
• 비용-편익 분석과 여러 단계로 솔루션을 출시할 방법의 이해
• 비즈니스,머신 러닝 모델(정확도, F1점수, AUC), 경제성(핵심성과 지표)에 대한 명확하고 측정
  가능한 성공 지표 정의
• 타당성 보고서 작성

2. 데이터 준비 (Data Preparation)

1. 데이터 수집 및 라벨링
2. 데이터 정리 (Cleaning)
3. 데이터 처리
4. 데이터 관리

3. 모델 엔지니어링 (Model Engineering)

계획 단계의 모든 정보를 사용하여 머신러닝 모델을 구축하고 훈련
(e.g. 모델 메트릭 추적, 확장성 및 견고성 보장, 스토리지 및 컴퓨팅 리소스 최적화 등)

1. 광범위한 조사를 통해 효과적인 모델 아키텍처 구축
2. 모델 메트릭 정의
3. 학습 및 검증 데이터 셋으로 모델 학습, 검증
4. 실험, 메타데이터,기능,코드 변경 및 머신 러닝 파이프라인을 추적 (1~4번 → 기타 코드 정리)
5. 모델 압축 및 앙상블 수행
6. 도메인 지식 전문가를 통하여 결과 해석

4. 모델 평가 (Model Evaluation)

• 테스트 데이터 셋으로 모델 테스트, 전문가를 참여시켜 예측 오류 파악
• AI 솔루션 구축을 위한 산업적, 윤리적, 법적 프레임워크를 준수하는지 확인
• 무작위 및 실제 데이터에 대한 견고성(robustness) 테스트
• 결과를 계획된 성공 지표와 비교하여 모델 배포 여부 결정

5. 모델 배포 (Model Deployment)

• 현재 시스템에 머신러닝 모델을 배포
• 일반적으로 클라우드 및 로컬 서버, 웹 브라우저, 소프트웨어 패키지 등에 배포할 수 있으며, API, 웹, 앱, 플러그인 또는 대시보드를 사용하여 접근

6. 모니터링 및 유지, 관리 (Monitoring and Maintenance)

• 배포한 후에는 지속적으로 시스템을 모니터링하고 개선
• 모델 지표, 하드웨어 및 소프트웨어 성능, 고객 만족도를 모니터링
• 데이터 처리 및 모델 학습 기술을 개선하고, 새로운 소프트웨어와 하드웨어를 업데이트하기 위해 전체 머신 러닝 수명 주기를 개선해야 하는 경우도 있음

테스트 데이터 표준화 및 변환, 이진 분류, 배치(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())

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)

Tensor 생성 및 변환

Tensor 초기화

초기화 하지 않은 Tensor

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

다양한 Tensor 생성

CUDA Tensor

CUDA

• Compute Unified Device Architecture, NVIDIA가 만든 GPGPU 플랫폼 및 API 모델
• GPU 가상 명령어 집합을 쓸 수 있게 해주는 소프트웨어
• GPU는 병렬 데이터 처리 능력이 뛰어나기 때문에 AI 분야에서는 GPU를 주로 사용함
• CUDA 메서드를 설명하는 PyTorch 공식 문서
• GPU와 AI의 관련성

# 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)

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 데이터 타입

타입 캐스팅

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

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

Tensor 기초 함수 및 메서드

표본분산

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

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

표본분산

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

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

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

DetEval이란?

DetEval(Detection Evaluation)은 OCR(Optical Character Recognition)에서 문자 영역 검출 성능을 평가하기 위한 대표적인 메트릭으로, 이는 객체 검출(Object Detection)에서 IoU(Intersection over Union)를 기반으로 성능을 측정하는 것과 유사하지만, OCR 특화 기준을 적용한다는 점이 특징.

DetEval에서는 검출된 영역과 GT를 IoU 기준이 아니라, 영역 기반 Recall과 Precision을 활용한 매칭 방식을 사용

• Recall 기반 매칭: GT 박스 내에서 검출된 박스의 영역이 일정 비율 이상 포함되면 TP(참양성) 으로 간주
• Precision 기반 매칭: 검출된 박스가 GT와 겹치는 비율이 일정 기준을 넘으면 TP(참양성) 으로 인정

1번 과정

모든 정답/예측박스들에 대해서 Area Recall, Area Precision을 미리 계산해낸다. 여기서 Area Recall, Area Precision은 다음과 같음.

• Area Recall = 정답과 예측박스가 겹치는 영역 / 정답 박스의 영역
• Area Precision = 정답과 예측박스가 겹치는 영역 / 예측 박스의 영역

2번 과정

모든 정답 박스와 예측 박스를 순회하면서, 매칭이 되었는지 판단하여 박스 레벨로 정답 여부를 측정한다.. 박스들이 매칭이 되는 조건은 박스들을 순회하면서, 위에서 계산한 Area Recall, Area Precision이 0 이상일 경우 매칭 여부를 판단하게 되며, 박스의 정답 여부는 Area Recall 0.8 이상, Area Precision 0.4 이상을 기준으로 하고 있음

• 매칭이 되었는가 대한 3가지 조건
  • one-to-one match: 정답 박스 1개와 예측 박스 1개가 매칭 && 기본조건 성립
  • one-to-many match: 정답 박스 1개와 예측 박스 여러개가 매칭되는 경우. 이 조건에서는 박스 recall / precision 에 0.8 로 penalty가 적용
  • many-to-one match: 정답 박스 여러개와 예측박스 1개가 매칭되는 경우

왼쪽과 같이 다음과 같은 정답박스가 존재하는 이미지에 대해서, 오른쪽과 같이 예측하였다고 가정

1번 과정을 통하여, 모든 박스들 사이의 Area Recall, Area Precision을 계산해 놓는다. 왼쪽에 정답박스와 예측박스를 겹쳐서 그림

• G1과 P1은 one-to-one match가 성립되었고, Area Recall, Area Precision 모두 0.99로 threshold 이상이므로, 정답으로 책정
• G2, G3와 P2는 many-to-one match가 성립되었고, Area Recall = (0.81+0.99)/2 = 0.9, Area Precision = (0.41+0.5) = 0.91 로 threshold 이상으로 정답으로 책정
• G4와 P3, P4는 one-to-many match가 성립되었고, Area Recall = (0.46+0.42) = 0.88, Area Precision = (1.0+0.92)/2 = 0.96 로 threshold 이상으로 정답으로 책정되
• 현재 이미지에서의 Recall, Precision, F1-Score
  • Recall = ( 1(G1) + 1(G2) + 1(G3) + 0.8(G4) ) / 4(len(gt)) = 0.95
  • Precision = ( 1(P1) + 1(P2) + 0.8(P3) + 0.8(P4) ) / 4(len(prediction)) = 0.9
  • F1-Score = 2 × 0.95 × 0.9 / (0.95 + 0.9) = 0.92

1. 모든 이미지에 대하여 Recall, Precision F1-Score을 구한 후, 해당 값을 모든 정답/예측박스에 대해 평균내어 최종 점수를 계산.
   1. 예를 들어, image1, image2 두 개의 테스트 이미지가 존재하고, 계산의 편의성을 위해서 image1은 위의 예시와 동일, image2는 정답/예측박스가 1개이고 맞았다면, 해당 테스트 셋에서 최종 점수는 0.94 점

• Final Recall = (1 + 1 + 1 + 0.8 + 1) / 5 = 0.96
• Final Precision = (1 + 1 + 0.8 + 0.8 + 1) / 5 = 0.92
• Final F1-Score = 2 × 0.96 × 0.92 / (0.96 + 0.92) = 0.94
• 이 때, 분모가 5인 이유는 image1에서 정답/예측박스 4개, image2에서 정답/예측박스가 1개이기 때문임

Serving 패턴

디자인 패턴

• 과거부터 문제를 해결한 사람들이 반복된 내용을 패턴으로 정리
• 코드의 재사용성, 가독성, 확장성 등을 향상시키기 위한 목적으로 도입
• 주로 객체 지향 프로그래밍에서 사용되지만 다른 프로그래밍 패러다임에서도 유용
• 개발 과정의 커뮤니케이션에서 이런 패턴을 사용하기도 함
• 예시) 이번 서빙은 Batch 패턴으로 구현하시죠!
• 안티 패턴 : 보통 좋지 않다고 알려진 패턴

머신러닝 디자인 패턴

• 머신러닝의 특수성으로 별도의 디자인 패턴이 생김
  • 일반적인 소프트웨어 개발: Only Code
  • 머신러닝 개발의 특수성 : Data, Model, Code

머신러닝 서비스를 개발하다 고민하는 특수한 포인트

• 대용량 Model Load
• Model 관리
• 데이터를 대량으로 가져와서 전처리
• 데이터를 통계적으로 확인해서 이상치 제외
• 예측 요청 후 반응 시간이 오래 소요될 수 있음(모델이 연산하는 과정 이슈)
• 학습, 예측, 운영하면서 생기는 노하우 => 패턴화
• 지금도 계속 변하고 있을 머신러닝 디자인 패턴 (LLM 이후에도 LLMOps 분야에서 계속 새로운 시도가 생기고 있을 것)
• 상황에 따라 다르기에 이런 방법들이 항상 Best는 아니지만 구현하기 전에 참고할 수 있음
• 소개하는 여러 패턴을 합쳐서 하나의 패턴으로 만들 수도 있음

Serving 4가지 패턴

• Batch Serving
  1. Batch 패턴
• Online Serving
  1. Web Single 패턴
  2. Synchronous 패턴
  3. Asynchronous 패턴

Batch Serving

Batch 패턴

• 추천 모델이 있을 때, 가장 간단하고 최저의 비용으로 운영 환경에 배포하기 위해서는 어떻게 해야 할까?
  • 주기적으로 이 추천 모델에 사용자 데이터를 Input Data로 넣어서 예측하고, Output 으로 나오는 사용자 별 추천 결과를 DB에 저장하기
  • 추천 결과를 활용하는 서버쪽에서는 이 DB에 주기적으로 접근해 추천 결과를 노출

실시간성이 필요 없는 경우에 주기적으로 예측 결과를 DB에 저장하고, 활용하는 쪽은 DB에서 결과를 읽어와서 사용

Job Management Server

• 작업을 실행하는 서버
• Apache Airflow 등을 주로 사용
• 특정 시간에 주기적으로 Batch Job을 실행시키는 주체

Job

• 어떤 작업 실행에 필요한 모든 활동
• Job이 실행되는 과정에 Model Load, Data Load도 포함
• Python Script를 그냥 실행시키는 경우도 있고, Docker Image로 실행하는 경우도 존재

Data

• 서비스에서 사용하는 DB(AWS RDS 등) 또는 데이터 웨어하우스에 저장
• 서비스 서버에서도 데이터를 불러오는 스케줄링 Job이 존재 => 특정 시간 단위로 가져옴

Usecase

• 예측 결과를 실시간으로 얻을 필요가 없는 경우
• 대량의 데이터에 대한 예측을 하는 경우
• 예측 실행이 시간대별, 월별, 일별로 스케줄링해도 괜찮은 경우

장점

• 기존에 사용하던 코드를 재사용 가능
• API 서버를 개발하지 않아도 되는 단순함
• 서버 리소스를 유연하게 관리할 수 있음(오래 걸릴 Job에 서버 리소스 추가 투입)

고민할 점

• 별도의 스케줄러(예 : Apache Airflow) 필요

Online Serving

Web Single 패턴

Web : 웹 기반 애플리케이션 Single : 단일, 하나의 요청을 처리

• 배치 단위로 서빙을 하면 결국 결과 반영까지의 시간 텀이 존재하기 때문에, 이를 더 실시간에 가깝게 하려면 어떻게 해야 할까?
  • 모델이 항상 Load 된 상태에서 예측을 해주는 API 서버를 만들고, 추천 결과가 필요한 경우 서비스 서버에서 이 예측 서버에 직접 요청하면 어떨까?

API 서버 코드에 모델을 포함시킨 뒤 배포, 예측이 필요한 곳(클라이언트, 서버 등)에서 직접 Request 요청

예측/추론 Server

• FastAPI, Flask 등으로 단일 REST API 서버를 개발 후 배포
• 예 : POST api-server-url/predict로 예측
• API 서버가 실행될 때 모델을 로드
• API 로직 내에 전처리도 같이 포함

Client

• 앱에서 직접 요청할 수도 있고, 앱이 서비스 서버에 요청하고 서비스 서버가 예측 서버에게 또 요청할 수도 있음(개발을 어떻게 했는지에 따라 다름)
• 웹페이지라면 브라우저에서 요청

Data

• 요청할 때 같이 데이터를 담아 요청
• 상황에 따라 데이터의 용량 제한이 있을 수 있음

Load Balancer

• 트래픽을 분산시켜서 서버에 과부하를 걸리지 않도록 해줌
• Nginx, Amazon ELB(Elastic Load Balancing) 등을 사용

Usecase

• 예측 서버를 빠르게 출시하고 싶은 경우
• 예측 결과를 실시간으로 얻을 필요가 있는 경우
• Web Single 패턴을 기본으로 삼고 이어지는 패턴들을 적용

장점

• 보통 하나의 프로그래밍 언어로 진행
• 아키텍처의 단순함
• 처음 사용할 때 좋은 방식

고민할 점

• 구성 요소 하나(모델, 전처리 코드 등)가 바뀌면 전체 업데이트가 필요
• 모델이 큰 경우, 로드에 시간이 오래 걸릴 수 있음
• 요청 처리가 오래 걸리는 경우, 서버에 부하가 걸릴 수 있음

Synchronous 패턴

Synchronous : 동기식

하나의 작업이 끝날 때까지 다른 작업을 시작하지 않고 기다리고, 작업이 끝나면 새로운 작업을 시작하는 방식

• FastAPI로 모델을 Web Single 패턴으로 구현했다고 했을 때, 클라이언트는 API 서버로 요청을 한 뒤 이 요청이 끝날 때까지 기다려야 함
• Web Single 패턴을 동기적(Synchronous)으로 서빙
  • 기본적으로 대부분의 REST API 서버는 동기적으로 서빙

장점

• 아키텍처의 단순함
• 예측이 완료될 때까지 프로세스가 다른 작업을 할 필요가 없어서 Workflow가 단순해짐

고민할 점

• 예측 속도가 병목이 됨 (동시에 1000개의 요청이 올 경우 대기 시간이 길어지거나 Drop 혹은 Timeout)
• 예측 지연으로 사용자 경험이 악화될 수 있음

Usecase

• 예측의 결과에 따라 클라이언트의 로직이 즉각적으로 달라져야 하는 경우
  • 예시) 예측 결과가 강아지냐, 고양이냐에 따라 클라이언트에서 보여주어야 하는 페이지가 다른 경우 Predict Output => 강아지 => 강아지 관련 Page => 고양이 => 고양이 관련 Page

Asynchronous 패턴

Asynchronous : 비동기식

• 하나의 작업을 시작하고, 결과를 기다리는 동안 다른 작업을 할 수 있음
• 작업이 완료되면 시스템에서 결과를 알려줌
• 음식점에서 진동벨을 사용하는 경우가 비동기식과 유사

등장 배경

• Synchronous 패턴으로 서빙하니까, API 서버에서 이제 수많은 요청을 감당할 수가 없어짐
  • API 서버가 계속 부하가 걸려서 모든 요청에 대한 응답이 느려지기 시작
  • 응답이 느려지니, 클라이언트에서도 응답 받은 이후의 로직을 진행하지 못함
• API 서버의 cpu와 memory를 증가하면 해소가 되긴 하겠지만, 단기간의 해결이고 요청이 늘어나며 결국 똑같아짐

어떻게 해야 할까?

• API 서버의 부하가 늘지 않게 요청을 하며 다 처리할 수 있어야 함
• 클라이언트는 당장 결과를 받지 않더라도, 최종적으로 결과를 받아야 함

Queue

• 클라이언트와 예측 서버 사이에 메시지 시스템(Queue)을 추가
• 대표적인 메시지 프레임워크 : Apache Kafka
• 지하철 물품 보관소와 유사한 역할
• Push : 메시지 저장
• Pull : 메시지를 가지고 와서 작업(예측) 수행

Usecase

• 예측과 클라이언트 진행 프로세스의 의존성이 없는 경우
• 예측 요청을 하고 응답을 바로 받을 필요가 없는 경우
• 예측을 요청하는 클라이언트와 응답을 반환하는 목적지가 분리된 경우

장점

• 클라이언트와 예측 프로세스가 분리 => 관계가 의존적이지 않음
• 클라이언트가 예측을 기다릴 필요가 없음

고민할 점

• 메시지 Queue 시스템을 만들어야 함
• 전체적으로 구조가 복잡해짐
• 완전한 실시간 예측엔 적절하지 않음(메시지를 가져갈 때 시간이 소요될 수 있음)

요약

디자인 패턴 = 템플릿 머신러닝 디자인 패턴 : 머신러닝의 특수성(Data, Model, Code)으로 생긴 패턴

• 모든 패턴을 외울 필요는 없고, 어떤 맥락에 쓰면 좋은지 이해하기. 개발하기 전에 떠올리기

Serving의 유형 별 패턴

• Batch Serving
  1. Batch 패턴
• Online Serving
  1. Web Single 패턴
  2. Synchronous 패턴
  3. Asynchronous 패턴

Anti Serving 패턴

Anti Serving 패턴은 권장되지 않는 Serving 패턴, 즉 주의해야 할 패턴

Online Bigsize 패턴

실시간 대응이 필요한 온라인 서비스에 예측에 오래 걸리는 모델을 사용하는 경우

(예시) 서버가 실행되는데 몇 분씩 소요되고, 요청에 대해 응답이 몇 초씩 걸릴 경우

문제

• 일반적으로 Bigsize 모델은 배포할 때 서버 실행과 서빙이 느림
• 속도와 비용 Tradeoff를 조절해 모델 경량화하는 작업이 필요

대안

• 실시간이 아닌 배치로 변경하는 것도 가능한지 검토
• 중간에 캐시 서버를 추가하고, 전처리를 분리하는 것도 Bigsize를 탈피하는 방법

All-in-One 패턴

하나의 서버에 여러 예측 모델을 띄우는 경우 (예시) predict1, predict2, predict3으로 나눠서 하나의 서버에서 모두 실행하는 경우

문제

• 라이브러리 선택 제한이 존재함
• 장애가 발생할 경우(서버가 갑자기 다운) 시스템이 마비됨 (SPOF, Single Point Of Failure)

대안

• 모델 별로 서버를 분리하여 배포 (Microservice 패턴)

요약

• Online Bigsize 패턴 : 예측이 오래 걸리는 모델을 사용하는 경우
• All-in-one 패턴 : 하나의 서버에 여러 예측 모델을 띄우는 경우