AI와 데이터 사이언스의 이론과 실전

CatBoost(Categorical Boosting)

큐트아리 — Wed, 10 Apr 2024 23:24:49 +0900

CatBoost의 기본 개념

이름의 유래: "CatBoost"라는 이름은 'Categorical'과 'Boosting'의 합성어로, 범주형 데이터에 초점을 맞춘 부스팅 알고리즘이라는 의미를 담고 있습니다.
개발자: CatBoost는 Yandex, 러시아의 주요 검색 엔진 기업에 의해 개발되었습니다.

CatBoost의 주요 특징

범주형 데이터 처리: CatBoost는 별도의 전처리 없이 범주형 변수를 효과적으로 처리할 수 있도록 설계되었습니다. 대부분의 다른 기계 학습 모델과 달리, 범주형 데이터를 수치형으로 변환하는 과정이 필요 없습니다.
자동 하이퍼파라미터 튜닝: CatBoost는 하이퍼파라미터 튜닝이 비교적 쉬운 편이며, 기본 설정만으로도 우수한 성능을 보여줍니다.
결측치 처리: 자체적으로 결측치를 처리하는 메커니즘을 갖추고 있어, 사용자가 별도로 결측치 처리를 하지 않아도 됩니다.
속도와 규모: CatBoost는 큰 데이터셋에서도 빠르게 작동하며, GPU 지원을 통해 더 빠른 학습 속도를 제공합니다.

CatBoost의 작동 원리

Symmetric Trees: CatBoost는 대칭 트리(Symmetric Trees)라는 특별한 유형의 트리를 사용합니다. 이는 모델의 성능과 속도 향상에 기여합니다.
Ordered Boosting: CatBoost의 중요한 특징 중 하나는 'Ordered Boosting'입니다. 이는 훈련 데이터에 순서를 부여하고, 각 단계에서는 과거의 모든 데이터를 사용하지 않고 일부만을 사용하여 과적합을 방지합니다.
Leaf-wise Growth Strategy: CatBoost는 트리를 구축할 때 레벨별로 확장하는 대신, 손실을 최대한 줄일 수 있는 리프에서 성장하는 전략을 사용합니다.

CatBoost 사용 사례

CatBoost는 다양한 분야에서 사용될 수 있습니다. 예를 들어, 금융 분야에서의 사기 탐지, 의료 분야에서의 질병 예측, 인터넷 검색 및 추천 시스템, 분류 문제 등에서 뛰어난 성능을 보입니다.

CatBoost와 다른 Gradient Boosting 모델과의 차이

CatBoost는 XGBoost나 LightGBM 같은 다른 Gradient Boosting 알고리즘과 비교할 때, 범주형 데이터를 직접 처리할 수 있다는 점에서 큰 차이가 있습니다. 이 외에도 고유의 알고리즘 최적화로 인해 다른 모델 대비 과적합에 더 강하며, 안정적인 성능을 제공합니다.

대칭 트리(Symmetric Trees)란?

정의: 대칭 트리는 CatBoost에서 사용되는 결정 트리의 일종으로, 트리의 각 레벨에서 분할 규칙이 모든 노드에 동일하게 적용되는 구조를 가지고 있습니다. 즉, 트리의 같은 레벨에 있는 모든 노드는 같은 기준으로 데이터를 분할합니다.
대칭성: 이러한 대칭성 때문에, 같은 레벨의 모든 노드는 구조적으로 동일한 결정 경로를 갖게 됩니다. 이는 트리를 더 단순하고 효율적으로 만들어주며, 예측 속도를 향상시키는 데 기여합니다.

대칭 트리의 장점

계산 효율성: 대칭 트리는 노드를 생성할 때 복잡한 계산을 줄여줍니다. 각 레벨에서 동일한 분할 기준을 사용하기 때문에, 불필요한 계산을 피할 수 있습니다.
메모리 효율성: 대칭 구조는 트리의 저장과 처리에 있어 메모리 사용량을 최소화합니다. 또한, 이러한 구조는 GPU와 같은 병렬 컴퓨팅 환경에서도 효율적입니다.
예측 속도 향상: 대칭 트리는 예측 시간을 단축시킵니다. 모든 레벨에서 같은 기준을 사용하기 때문에, 예측 과정이 빠르고 간결합니다.
과적합 방지: 대칭 트리는 과적합의 위험을 줄여줍니다. 복잡한 트리 구조보다 간단하게 유지되기 때문에, 모델이 훈련 데이터에 지나치게 최적화되는 것을 방지합니다.

Leaf-wise Growth Strategy란?

정의: Leaf-wise Growth Strategy는 결정 트리를 구축할 때, 각 단계에서 가장 큰 손실 감소를 가져다 주는 리프(leaf) 노드를 분할하는 방식입니다.
작동 원리: 이 방식에서는 전체 트리의 균형을 맞추는 대신, 가장 많은 이득을 줄 수 있는 특정 리프 노드에 집중하여 트리를 성장시킵니다.

Leaf-wise 대 Level-wise

Level-wise Strategy: 일반적인 부스팅 알고리즘(예: XGBoost)에서 사용되는 Level-wise 전략은 트리의 모든 리프 노드를 동일하게 확장합니다. 이는 균형 잡힌 트리를 만들지만, 꼭 필요하지 않은 분할을 할 수도 있습니다.
Leaf-wise Strategy: 반면 Leaf-wise 전략은 가장 큰 손실을 감소시킬 수 있는 리프에 집중하여 트리를 확장합니다. 이는 불필요한 분할을 줄이고, 더 정확한 학습 결과를 도출할 수 있습니다.

Leaf-wise Growth Strategy의 장점

정확도 향상: 손실 감소가 큰 리프에 집중함으로써, 더 정확한 예측 모델을 만들 수 있습니다.
효율적인 학습: 불필요한 분할을 줄임으로써 학습 과정이 더 효율적이 됩니다.
과적합 방지: CatBoost는 Leaf-wise 전략을 사용하면서도 과적합을 방지하기 위한 다양한 기술(예: 정규화, 랜덤화)을 적용합니다.

고려사항

과적합 위험: Leaf-wise 전략은 극단적인 경우 과적합으로 이어질 수 있습니다. 그러나 CatBoost는 이를 완화하기 위한 기법들을 적용합니다.
데이터 크기: 대규모 데이터셋에서 Leaf-wise 전략은 더욱 빛을 발합니다. 소규모 데이터셋에서는 이 전략이 과적합을 유발할 위험이 있을 수 있습니다.

배깅과 부스팅의 원리와 주요 알고리즘

큐트아리 — Wed, 10 Apr 2024 22:35:26 +0900

배깅(Bagging)

기본 원리: 배깅(Bagging, Bootstrap Aggregating의 줄임말)은 다수의 분류기가 훈련 데이터셋의 서로 다른 무작위 샘플에 대해 각각 학습을 수행하고, 이 분류기들의 예측을 평균화하여 최종 결과를 결정합니다.
목적: 배깅의 주 목적은 훈련 데이터의 무작위 샘플링을 통해 분류기의 분산을 감소시켜 과적합을 줄이는 것입니다.
작동 방식: 주로 부트스트랩 샘플링(복원 추출)을 사용하여 원래 데이터셋의 크기와 동일한 여러 서브셋을 생성합니다. 각 서브셋으로 모델을 개별적으로 훈련시키고, 이 모델들의 결과를 결합합니다.
대표적 모델: 랜덤 포레스트(Random Forest)가 대표적인 배깅 기반 모델입니다. 랜덤 포레스트는 다수의 결정 트리들로 구성되며, 각 트리는 데이터셋의 서로 다른 샘플로 훈련됩니다.

부스팅(Boosting)

기본 원리: 부스팅은 약한 학습기(Weak Learner)를 순차적으로 훈련시키면서, 잘못 예측된 데이터에 대해 가중치를 부여하여, 다음 학습기가 더 잘 예측할 수 있도록 하는 방식입니다.
목적: 부스팅은 약한 학습기의 성능을 개선하여 강한 학습기를 만드는 것에 중점을 둡니다. 오류를 줄이기 위해 학습기 간의 연속적인 학습을 강조합니다.
작동 방식: 초기에는 모든 데이터에 동일한 가중치가 부여되지만, 각 반복 과정에서 잘못 분류된 데이터에 대한 가중치가 증가합니다. 이렇게 각기 다른 가중치가 적용된 데이터셋에 대해 새로운 학습기가 학습을 수행하고, 이 과정을 반복합니다.
대표적 모델:
- AdaBoost(Adaptive Boosting): 오류 데이터에 가중치를 부여해가며 순차적으로 모델을 구축합니다.
- Gradient Boosting: 손실 함수의 기울기에 따라 모델을 업데이트합니다. XGBoost, LightGBM, CatBoost 등이 Gradient Boosting의 확장된 형태입니다.

배깅과 부스팅의 차이점

학습 방식: 배깅은 병렬로 각 모델이 독립적으로 학습되는 반면, 부스팅은 순차적으로 학습하여 이전 모델의 오류를 개선합니다.
주 목적: 배깅은 분산 감소(과적합 방지)에, 부스팅은 편향 감소(성능 향상)에 초점을 맞춥니다.
샘플 가중치: 배깅에서는 각 모델이 동일한 확률로 데이터를 샘플링하지만, 부스팅에서는 오류를 더 많이 범한 데이터에 더 큰 가중치를 부여합니다.

[Pytorch]파이토치로 구현한 선형회귀

큐트아리 — Sun, 31 Mar 2024 20:40:09 +0900

1. 단항 선형 회귀 실습

한개의 입력이 들어가서 한 개의 출력이 나오는 구조
y = Wx + b
w는 weight, b는 잔차
x가 1개임으로 단항 선형 회귀

import torch

import torch.nn as nn

import torch.optim as optim

import matplotlib.pyplot as plt

import pandas as pd

import numpy as np

torch.manual_seed(2024)

# manual_seed : 랜덤값 고정

# 이렇게 랜덤값을 고정하면 제 결과와 이 글을 보고 따라하시는 여러분들의 결과가 같아집니다

x_train = torch.FloatTensor([[1],[2],[3]])

y_train = torch.FloatTensor([[2],[4],[6]])

print(x_train, x_train.shape)

print(y_train, y_train.shape)

plt.figure(figsize = (6,4))

plt.scatter(x_train,y_train)

딱봐도 한줄로 그을 수 있겠죠?

이렇게 선으로 표현이 가능한 애들의 선 방정식을 구하는 것을 선형회귀라고 합니다.

# 직선의 방정식으로 만들기

# y = Wx + b

# y = 2x

# nn.Linear(input의 수,output의 수,bias=bool)

# bias=False면 b(절편)을 안구하겠다는 의미 -> 정확도가 떨어질수있음

model = nn.Linear(1,1)

print(model)

이렇게하면 1개의 변수를 입력으로 받아 1개의 아웃풋 값을 출력하고 절편을 계산하는 model이 완성됩니다.

# 학습을 안한 상태에서 예측하라고하니 W와 b가 랜덤으로 정해져서 결과값이 엉망으로 나옴

y_pred = model(x_train)

y_pred

print(list(model.parameters())) # W : 0.0634 , b : 0.6625

# y = 0.0634x + 0.6625

이렇게 학습을 안한 상태의 모델은 이상한 결과값을 가져옵니다.

당연히 그럴 수 밖에 없는게 모델을 사람으로 치자면 내가 뭔가를 1개 주면 너가 1개를 만들어서 돌려줘~하고 말한 상태에서 아무거나 준 상태입니다. 모델은 ??? 뭘 달라는건지 모르겠지만 일단 아무거나 줄게! 하고 준 상태인거죠.

이 때, mse를 구해보겠습니다.

# mse 값 구하기

((y_train - y_pred)**2).mean()

mse는 단독으로는 크게 쓸모가 없습니다.

지금이야 아웃풋값이 2,4,6인 정수인걸 알고 있으니까 오차의 제곱의 평균인 mse가 저정도면 크다. 실제값이 2,4,6인데 한 값당 오차의 제곱 평균이 12정도이면 루트값을 구했을때 3.xx 정도이니 오차가 어마어마하군. 이렇게 알 수 있지만 현업에서는 저정도로 계산하기가 어렵습니다. 실제값도 너무 많을 뿐더러 실제값의 단위도 중요하고 실제값이 저렇게 고르게 분포되어 있지도 않을테니까요. 그러니 지금 학습이 안된 상태의 모델의 mse와 학습한 모델의 mse를 비교해서 개선이 되었다!를 아는 것이 중요합니다.

그러니 이 mse를 통해 손실함수를 사용하면 좋겠죠? 모델은 손실함수의 값을 최저로 하는 것을 목표로 학습을 진행하니까요.

'''

SGD(Stochastic Gradient Descent)

- 기존의 그래디언트 디센트는 모든데이터를 하나하나씩 뽑아서 계산하며 최솟값찾았지만

- SGD는 랜덤하게 데이터를 하나씩 봅아서 loss를 만듦(랜덤이라 Stochastic)

- 데이터를 뽑고 데이터를 다시 넣고 반복

- 빠르게 방향을 결정

학습률(learning rate)

- 한번 움직이는 거리(incresent step)

- 독립변수가 많아서 차원이 많은 데이터의 경우는 learning rate를 작게

'''

# 뒤에 익명함수 구현

loss = nn.MSELoss()(y_pred,y_train)

loss

optimizer = optim.SGD(model.parameters(),lr=0.01)

# optimizer 사용

# 1. gradient를 초기화

# 원래는 optimizer가 반복문 안에서 사용됨

# 러닝레이트만큼 움직일때마다 오차값을 새로 계산하게 항상 초기화 시켜야함

optimizer.zero_grad()

# 역전파 : 비용함수를 미분해서 gradient(기울기)를 실제적으로 계산

# 해당 값의 순간기울기를 계산

loss.backward()

# 기존의 기울기와 바이어스를 업데이트

optimizer.step()

print(list(model.parameters())) # 0.2177x + 0.7267

# 반복 학습을 통해 틀린 W, b를 수정하면서 오차를 계속 줄여나감

# epochs : 반복 학습 횟수(에포크)

epochs = 1000

for epoch in range(epochs + 1):

y_pred = model(x_train)

loss = nn.MSELoss()(y_pred, y_train)

optimizer.zero_grad()

loss.backward()

optimizer.step()

if epoch % 100 == 0:

print(f'Epoch: {epoch}/{epochs} Loss: {loss:.6f}')

print(list(model.parameters())) # W:1.9499 , b: 0.1138

x_test = torch.FloatTensor([[8]])

y_pred = model(x_test)

print(y_pred)

학습되지 않은 값인 8을 넣었을때 잘 나오는 것을 알 수 있습니다.

2. 다중 선형 회귀

여러 개의 입력이 들어가서 한 개의 출력이 나오는 구조이것
y = W ⑴ x ⑴ + W ⑵x ⑵ + ..... + b
x변수가 2개 이상인 회귀 분석

x_train = torch.FloatTensor([[73, 80, 75],

[93, 88, 93],

[89, 91, 90],

[96, 98, 100],

[73, 66, 70]])

y_train = torch.FloatTensor([[150], [190], [180], [200], [130]])

print(x_train, x_train.shape)

print(y_train, y_train.shape)

다중 선형 회귀도 모델 쌓는것과 학습하는 코드는 똑같습니다.

다만 이전에는 nn.Linear(1,1) 즉, 1개의 input에 1개의 output이였다면 이젠 nn.Linear(3,1) 즉, 3개의 input에 1개의 output으로 코드를 짜야합니다.

# 모델 만들기

model = nn.Linear(3,1)

optimizer = optim.SGD(model.parameters(), lr=0.00001)

epochs = 150000

for epoch in range(epochs + 1):

y_pred = model(x_train)

loss = nn.MSELoss()(y_pred, y_train)

optimizer.zero_grad()

loss.backward()

optimizer.step()

if epoch % 10000 == 0:

print(f'Epoch: {epoch}/{epochs} Loss: {loss:.6f}')

print(list(model.parameters())) # W:-1.4802, -0.2136, 3.6704 , b: 0.1138

x_test = torch.FloatTensor([[92,90,89]])

y_pred = model(x_test)

print(y_pred)

지금까진 직접 작성한 데이터셋을 사용했는데요 이번엔 csv파일을 불러와서 해보겠습니다.

3. temps 데이터셋

천안지역의 1년 날씨 데이터
천안에 있는 다른 해의 날짜를 예측하는 것이 목표
기온에 따른 지면온도 예측하기

# df에 데이터프레임으로 불러오기

df = pd.read_csv('/content/drive/MyDrive/KDT/머신러닝과 딥러닝/data/temps.csv',encoding= 'euc-kr')

# df의 null값 구분하기

df.isna().mean()

# df의 null 제거하기

df.dropna(inplace=True)

df.isna().mean()

# x_data에 기온 데이터를 저장

x_data = df[['기온(°C)']]

# 데이터프레임을 텐서로 변경

x_data = torch.FloatTensor(x_data.values)

# x_data = x_data.reshape(-1, 1)

# y_data에 지면온도 데이터를 저장

y_data = df[['지면온도(°C)']]

# 데이터프레임을 텐서로 변경 -> 이런 형식으로 하면 차원이 지켜지는듯?

y_data = torch.FloatTensor(y_data.values)

# y_data = y_data.reshape(-1, 1)

print(x_data.shape, y_data.shape)

# scatter로 x_data와 y_data를 출력

plt.figure(figsize=(8,8))

plt.scatter(x_data, y_data)

plt.xlabel('기온(°C)')

plt.ylabel('지면온도(°C)')

plt.title('Scatter Plot')

plt.show()

저는 코랩을 써서 한글이 깨지지만 이것도 해결할 수 있습니다. 해결 방법은 추후에 별도로 글을 작성해서 올리겠습니다.

# 입력과 출력이 1개인 선형모델 생성

# SGD를 통해 옵티마이저 객체를 생성

model = nn.Linear(1, 1)

optimizer = torch.optim.SGD(model.parameters(), lr=0.001)

print(list(model.parameters()))

# 모델을 학습

# 오차함수는 MSELoss()를 사용

epochs = 1000

for epoch in range(epochs + 1):

y_pred = model(x_data)

loss = nn.MSELoss()(y_pred, y_data)

optimizer.zero_grad()

loss.backward()

optimizer.step()

if epoch % 100 == 0:

print(f'Epoch: {epoch}/{epochs} Loss : {loss : .6f}')

# 학습된 파라미터 확인

print(list(model.parameters())) # W:1.1182 , b: 0.1443

# 예측된 y값 구하기

# detach() : 텐서에서 다른 자료구조로 변환

y_pred = model(x_data).detach().numpy()

# scatter로 x_data와 y_data를 출력 후 예측된 선을 출력

# scatter로 x_data와 y_data를 출력

# 666

plt.figure(figsize=(8,8))

plt.scatter(x_data, y_data)

plt.scatter(x_data,y_pred)

plt.xlabel('기온(°C)')

plt.ylabel('지면온도(°C)')

plt.title('Scatter Plot')

plt.show()

선을 보면 완벽하게 데이터를 설명하진 못하지만 어느정도 기울기를 반영한 선형식이 완성된 것을 알 수 있습니다.

사실 지금과 같이 딥러닝 기반 선형회귀와는 달리 통계적인 의미의 선형회귀는 조건이 굉장히 까다롭습니다.

등분산성, 선형성, 독립성, 정규성, 다중공선성과 같은 조건들이 만족해야 선형회귀를 돌릴 때 의미있는 직선을 구할 수가 있습니다. 하지만 우리는 모델 학습의 기초에 대해서 쉽게 알기위해 선형회귀로 배워본 것임으로 예측 정확도가 낮은것에 집중하지말고 데이터의 형태를 확인하는 법과 학습코드를 작성하는 법에 집중해서 보면 도움이 될 것 입니다.

목적함수와 최적화 알고리즘, 경사하강법, 학습률과 배치사이즈

큐트아리 — Sun, 31 Mar 2024 19:41:29 +0900

흔히 말하는 모델을 학습시킬때, 모델을 무엇으로 평가를 하고 어떻게 학습해나가는 걸까요?

오늘은 모델의 평가기준인 목적함수와 성능개선 방법인 최적화 알고리즘에 대해서 알아보겠습니다.

최적화 알고리즘의 기본 개념

최적화 알고리즘은 주어진 문제에 대해 최적의 해결책을 찾는 과정입니다. 이 과정에서는 목표 함수(objective function)를 최대화하거나 최소화하는 변수의 값을 결정합니다. 최적화 문제는 다양한 제약 조건을 포함할 수 있으며, 이러한 제약 조건 하에서 최적의 해를 찾는 것이 목표입니다.

주요 최적화 알고리즘 종류

경사하강법(Gradient Descent): 함수의 기울기(경사)를 사용하여 최소점을 찾는 방법입니다. 이 방법은 머신러닝 모델을 학습시킬 때 널리 사용됩니다.
유전 알고리즘(Genetic Algorithm): 자연 선택과 유전자 변이 과정을 모방하여 최적의 해를 찾는 방법입니다. 복잡한 최적화 문제에 효과적으로 사용될 수 있습니다.
심화 학습(Deep Learning): 대규모 데이터셋에서 복잡한 패턴을 학습하여 최적화 문제를 해결하는 데 사용됩니다. 이 방법은 이미지 인식, 자연어 처리 등 다양한 분야에서 활용됩니다.

이제, 가장 많이 쓰이는 경사하강법에 대해서 알아보겠습니다.

경사하강법(Gradient Descent)

비용함수(mse와 같은 현재값과 예측값사이의 차이를 구하는 함수)의 값을 최소로 하는 W와 b를 찾는 알고리즘을 옵티마이저(최적화) 알고리즘이라고 함
옵티마이저 알고리즘 중 가장 기본적인 기술이 경사하강법이다
옵티마이저 알고리즘을 통해 W와 b를 찾아내는 과정을 "학습"이라고 부름

조금씩 기울기를 바꿔보면서 오차가 가장 작아지는 W값을 찾는 기법

그런데 이런 경사하강법에도 종류가 있습니다.

너무 복잡하죠? 하지만 대분류를 아시면 헷갈리지 않으실겁니다. 제가 아래에 요약을 해놓았으니 확인해보세요.

경사하강법(Gradient Descent)의 종류

배치 경사 하강법 (Batch Gradient Descent):
- 모든 훈련 데이터를 한 번에 사용하여 기울기를 계산하고 파라미터를 업데이트합니다.
- 전체 데이터셋이 크면 메모리 부담이 크고, 업데이트가 느릴 수 있지만 안정적으로 최적값에 수렴할 수 있습니다.
확률적 경사 하강법 (Stochastic Gradient Descent, SGD):
- 각각의 훈련 데이터마다 기울기를 계산하고 파라미터를 업데이트합니다.
- 각 단계에서의 업데이트는 불안정할 수 있지만, 빠르게 수렴할 수 있고 대규모 데이터셋에 유용합니다.
미니 배치 경사 하강법 (Mini-batch Gradient Descent):
- 전체 데이터셋을 작은 미니 배치로 나누고 각 미니 배치에 대해 기울기를 계산하고 파라미터를 업데이트합니다.
- 배치 경사 하강법과 SGD의 절충안으로, 업데이트가 빠르면서도 안정적으로 수렴할 수 있습니다.
모멘텀 최적화 (Momentum Optimization):
- 기존의 경사 하강법에 관성을 추가하여, 이전 업데이트의 효과를 고려합니다.
- 이전 그래디언트들의 가중 평균을 사용하여 진행 방향을 결정하므로 지역 최소값에 빠지지 않고 빠르게 수렴할 수 있습니다.
아다그라드 (Adagrad):
- 각각의 파라미터에 다른 학습률을 적용하여 많이 변화하지 않은 파라미터는 더 큰 학습률을 가지고, 자주 변화하는 파라미터는 작은 학습률을 가집니다.
- 주어진 문제에 따라 적응적으로 학습률을 조절하여 수렴 속도를 향상시킬 수 있습니다.
아담 옵티마이저 (Adam Optimizer):
- 모멘텀 최적화와 RMSProp을 합친 알고리즘으로, 그래디언트의 지수 가중 평균 및 제곱의 지수 가중 평균을 계산하여 업데이트합니다.
- 학습률의 보정과 그래디언트의 이동 평균을 사용하여 효과적으로 수렴할 수 있습니다.

목적함수(Objective Function)에 대한 이해

목적함수는 최적화 문제에서 최대화하거나 최소화하고자 하는 대상을 정의하는 함수입니다. 머신러닝, 인공지능, 경영과학 등 다양한 분야에서 중요한 역할을 합니다. 목적함수는 손실 함수(Loss Function), 비용 함수(Cost Function) 등으로도 불리며, 이는 문제의 성격에 따라 달라질 수 있습니다.

목적함수의 기본 개념

목적함수란?: 머신러닝 모델의 성능을 측정하거나, 경영과학에서 이익을 최대화하거나 비용을 최소화하는 등의 목적을 달성하기 위해 최적화하는 함수입니다. 이 함수의 값을 최소화하거나 최대화함으로써 최적의 해를 찾습니다. 1

목적함수의 종류

손실 함수(Loss Function): 모델의 예측값과 실제 값 사이의 차이를 측정하는 함수입니다. 손실 함수의 값이 작을수록 모델의 성능이 좋다고 평가됩니다.
비용 함수(Cost Function): 손실 함수의 값들을 데이터셋 전체에 대해 평균낸 값입니다. 모델의 전체적인 성능을 평가하는 데 사용됩니다.
목적 함수(Objective Function): 최적화하고자 하는 주요 목표를 정의하는 함수로, 손실 함수나 비용 함수를 포함할 수 있습니다. 2 3

목적함수의 중요성

목적함수는 최적화 문제에서 해결책의 방향성을 제시합니다. 머신러닝에서는 모델의 학습 방향을 결정하고, 경영과학에서는 의사 결정의 기준이 됩니다. 목적함수를 통해 문제의 해결책을 수학적으로 정의하고, 최적화 알고리즘을 사용하여 최적의 해를 찾을 수 있습니다.

목적함수는 문제 해결의 핵심입니다. 목적에 맞는 적절한 함수를 선택하고 최적화하는 과정을 통해, 더 나은 결정을 내릴 수 있습니다. 목적함수를 이해하고 적용하는 것은 다양한 분야에서 중요한 역할을 합니다.

요약

모델의 목적 : 목적함수값 최대 혹은 최소로 만들기

최적화 알고리즘 : 목적함수 값을 최대 최소로 만드는 방법

경사하강법 : 최적화 알고리즘의 한 종류, 시작점에서 기울기(경사)를 따라 목적 함수 값을 최적화하기 위해 조금씩 이동하는 방식

SGD, ADAM : 경사하강법의 종류

이렇게 그림으로 보면 이해가 편하죠? 최적화 알고리즘과 목적함수를 나눠놨지만 결국은 모델 안에서 연관성이 있습니다. 그저 이해하기 쉽게 나눠놓았습니다.

학습률 (Learning Rate) 개념

학습률은 각 반복(에폭)에서 가중치를 업데이트할 때 얼마나 '크게' 업데이트할지를 결정합니다.
신경망 모델을 훈련할 때 가중치를 업데이트하는 속도를 결정하는 하이퍼파라미터입니다.
너무 작은 학습률은 수렴하는 데 시간이 오래 걸릴 수 있으며, 학습이 지역 최소점(local minima)에서 멈출 수 있습니다.
반대로, 너무 큰 학습률은 발산(divergence)하거나 안정성이 없는 훈련을 초래할 수 있습니다.
일반적으로는 작은 학습률부터 시작하여 점진적으로 크기를 키워가며 모델의 성능을 모니터링하면서 최적값을 찾습니다.

배치 사이즈 (Batch Size) 개념

배치 사이즈는 각 반복에서 신경망에 전달되는 데이터 포인트의 수를 결정합니다.
작은 배치 사이즈는 더 많은 업데이트를 제공하지만, 계산 비용이 높을 수 있습니다.
큰 배치 사이즈는 더 안정적인 그레이디언트(gradient)를 제공할 수 있지만, 메모리 요구량이 늘어날 수 있습니다.
일반적으로는 GPU 또는 TPU와 같은 하드웨어의 메모리 용량에 맞게 배치 사이즈를 선택합니다.
또한 배치 사이즈가 작을수록 노이즈가 많이 발생하므로 학습이 더 많은 에폭을 거쳐야 할 수 있습니다.
신경망이 한번의 업데이트를 수행하기 위해 몇개의 데이터를 쓸 것인지를 의미합니다.

모델 학습에는 어떤 목적함수를 쓸 것인지, 어떤 최적화 알고리즘을 쓸것인지, 학습률을 몇으로 할것인지, 배치사이즈를 몇으로 할것인지 등을 통해 천차만별의 성능을 자기는 모델이 탄생합니다.

때문에 이런 개념을 확실히 잡고 모델을 학습시킬 때 다양하게 시도하고 고려한다면 여러분들도 좋은 모델을 만들 수 있을것입니다.

LSTM으로 주식예측

큐트아리 — Wed, 27 Mar 2024 10:20:27 +0900

import torch

import torch.nn

import torchvision.transforms as transforms

import torchvision.datasets

from torch.nn import Parameter

import torch.nn as nn

from torch import Tensor

import torch.nn.functional as F

from torch.utils.data import DataLoader

import matplotlib.pyplot as plt

from datetime import datetime

LSTM 모델 생성

class LSTM(nn.Module):

def __init__(self, num_classes, input_size, hidden_size, num_layers, seq_length):

super(LSTM, self).__init__()

self.num_classes = num_classes # 클래스

self.num_layers = num_layers # LSTM 계층 개수

self.input_size = input_size # 입력 크기(컬럼 개수)

self.hidden_size = hidden_size # 은닉층의 뉴런 개수

self.seq_length = seq_length # 시퀀스 길이

self.lstm = nn.LSTM(input_size=input_size, hidden_size=hidden_size,

num_layers=num_layers, batch_first=True) # lstm 계층

self.fc_1 = nn.Linear(hidden_size, 128) # 완전연결층

self.fc = nn.Linear(128, num_classes) # 출력층

self.relu = nn.ReLU()

def forward(self,x):

h_0 = torch.zeros(self.num_layers, x.size(0), self.hidden_size) # 은닉상태 초기화

c_0 = torch.zeros(self.num_layers, x.size(0), self.hidden_size) # 셀 상태 초기화

output, (hn, cn) = self.lstm(x, (h_0, c_0)) # lstm 계층에 은닉 상태와 셀 상태 적용

hn = hn.view(-1, self.hidden_size) # 완전연결층 적용을 위해 데이터 형태를 1차원으로 조정

out = self.relu(hn)

out = self.fc_1(out)

out = self.relu(out)

out = self.fc(out)

return out

plt.style.use('seaborn-whitegrid')

device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')

cuda = True if torch.cuda.is_available() else False

Tensor = torch.cuda.FloatTensor if cuda else torch.FloatTensor

# 난수 생성기의 시드(seed)를 설정

torch.manual_seed(125)

if torch.cuda.is_available() :

torch.cuda.manual_seed_all(125)

import yfinance as yf

df = yf.download('005930.KS',

start='2022-01-01',

end='2022-05-31') # 005930 : 삼성전자 주가

df.head()

# data check

fig = df['Close'].plot()

X = df.drop('Close', axis=1) # X, y 분리

y = df[['Close']]

from sklearn.preprocessing import StandardScaler, MinMaxScaler

ms = MinMaxScaler() # 0 ~ 1

ss = StandardScaler() # 평균 0, 분산 1

X_ss = ss.fit_transform(X)

y_ms = ms.fit_transform(y)

X_train = X_ss[:79, :]

X_test = X_ss[79:, :]

y_train = y_ms[:79, :]

y_test = y_ms[79:, :]

print('Training Shape :', X_train.shape, y_train.shape)

print('Testing Shape :', X_test.shape, y_test.shape)

num_epochs = 1000

lr = 0.0001

input_size=5 # 칼럼 개수

hidden_size=2 # 은닉층 유닛 개수

num_layers=1 # LSTM 계층 개수

num_classes=1 # 클래스 개수

model = LSTM(num_classes, input_size, hidden_size, num_layers, X_train_tensors_f.shape[1])

criterion = torch.nn.MSELoss()

optimizer = torch.optim.Adam(model.parameters(), lr=lr)

for epoch in range(num_epochs) :

outputs = model.forward(X_train_tensors_f) # 전방향 학습

optimizer.zero_grad()

loss = criterion(outputs, y_train_tensors) # 오차 계싼

loss.backward() # 기울기 계산

optimizer.step() # 오차 업데이트

if epoch % 100 == 0 :

print(f'Epoch : {epoch}, loss : {loss.item():1.5f}')

df_x_ss = ss.transform(X)

df_y_ms = ms.transform(y)

df_x_ss = torch.Tensor(df_x_ss)

df_y_ms = torch.Tensor(df_y_ms)

df_x_ss = torch.reshape(df_x_ss, (df_x_ss.shape[0], 1, df_x_ss.shape[1]))

from sklearn.metrics import mean_squared_error, mean_absolute_error

import numpy as np

# 예측값과 실제값 추출

predicted = model(df_x_ss).data.numpy()

actual = df_y_ms.data.numpy()

# inverse_transform으로 정규화된 값을 다시 변환

predicted = ms.inverse_transform(predicted)

actual = ms.inverse_transform(actual)

# MSE 계산

mse = mean_squared_error(actual, predicted)

print("Mean Squared Error (MSE):", mse)

# MAE 계산

mae = mean_absolute_error(actual, predicted)

print("Mean Absolute Error (MAE):", mae)

# RMSE 계산

rmse = np.sqrt(mse)

print("Root Mean Squared Error (RMSE):", rmse)

train_predict = model(df_x_ss)

predicted = train_predict.data.numpy()

label_y = df_y_ms.data.numpy()

predicted = ms.inverse_transform(predicted)

label_y = ms.inverse_transform(label_y)

plt.figure(figsize=(10, 6))

plt.axvline(x=datetime(2022,5,1), c='r', linestyle='--')

df['pred'] = predicted

plt.plot(df['Close'], label='Actual Data')

plt.plot(df['pred'], label='Predicted Data')

plt.title('Time-series Prediction')

plt.legend()

plt.show()

GRU로 주식예측

큐트아리 — Wed, 27 Mar 2024 10:09:29 +0900

import torch

import torch.nn

import torchvision.transforms as transforms

import torchvision.datasets

from torch.nn import Parameter

import torch.nn as nn

from torch import Tensor

import torch.nn.functional as F

from torch.utils.data import DataLoader

import matplotlib.pyplot as plt

from datetime import datetime

class GRU(nn.Module) :

def __init__(self, num_classes, input_size, hidden_size, num_layers, seq_length) :

super(GRU, self).__init__()

self.num_classes = num_classes

self.num_layers = num_layers

self.input_size = input_size

self.hidden_size = hidden_size

self.seq_length = seq_length

self.gru = nn.GRU(input_size=input_size,hidden_size=hidden_size,

num_layers=num_layers,batch_first=True)

self.fc_1 = nn.Linear(hidden_size, 128)

self.fc = nn.Linear(128, num_classes)

self.relu = nn.ReLU()

def forward(self, x) :

h_0 = torch.zeros(self.num_layers, x.size(0), self.hidden_size)

output, (hn) = self.gru(x, (h_0))

hn = hn.view(-1, self.hidden_size)

out = self.relu(hn)

out = self.fc_1(out)

out = self.relu(out)

out = self.fc(out)

return out

plt.style.use('seaborn-whitegrid')

device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')

cuda = True if torch.cuda.is_available() else False

Tensor = torch.cuda.FloatTensor if cuda else torch.FloatTensor

# 난수 생성기의 시드(seed)를 설정

torch.manual_seed(125)

if torch.cuda.is_available() :

torch.cuda.manual_seed_all(125)

import yfinance as yf

df = yf.download('005930.KS',

start='2022-01-01',

end='2022-05-31') # 005930 : 삼성전자 주가

df.head()

# data check

fig = df['Close'].plot()

X = df.drop('Close', axis=1) # X, y 분리

y = df[['Close']]

from sklearn.preprocessing import StandardScaler, MinMaxScaler

ms = MinMaxScaler() # 0 ~ 1

ss = StandardScaler() # 평균 0, 분산 1

X_ss = ss.fit_transform(X)

y_ms = ms.fit_transform(y)

X_train = X_ss[:79, :]

X_test = X_ss[79:, :]

y_train = y_ms[:79, :]

y_test = y_ms[79:, :]

print('Training Shape :', X_train.shape, y_train.shape)

print('Testing Shape :', X_test.shape, y_test.shape)

# 데이터셋 형태 및 크기 조정

X_train_tensors = torch.Tensor(X_train)

X_test_tensors = torch.Tensor(X_test)

y_train_tensors = torch.Tensor(y_train)

y_test_tensors = torch.Tensor(y_test)

X_train_tensors_f = torch.reshape(X_train_tensors, (X_train_tensors.shape[0], 1, X_train_tensors.shape[1]))

X_test_tensors_f = torch.reshape(X_test_tensors, (X_test_tensors.shape[0], 1, X_test_tensors.shape[1]))

print('Training Shape :', X_train.shape, y_train.shape)

아래와 같이 X_train_tensors_f를 만들어준 이유는 (데이터 개수, 시간 단계, 특성 개수)로 3차원 데이터로 만들어주기 위함입니다.

num_epochs = 1000

learning_rate = 0.0001

input_size=5

hidden_size=2

num_layers=1

num_classes=1

model=GRU(num_classes,input_size,hidden_size,num_layers,X_train_tensors_f.shape[1])

criterion = torch.nn.MSELoss()

optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)

for epoch in range(num_epochs) :

outputs = model.forward(X_train_tensors_f)

optimizer.zero_grad()

loss = criterion(outputs, y_train_tensors)

loss.backward()

optimizer.step()

if epoch % 100 == 0 :

print(f'Epoch : {epoch}, loss : {loss.item():1.5f}')

df_x_ss = ss.transform(X)

df_y_ms = ms.transform(y)

df_x_ss = torch.Tensor(df_x_ss)

df_y_ms = torch.Tensor(df_y_ms)

df_x_ss = torch.reshape(df_x_ss, (df_x_ss.shape[0], 1, df_x_ss.shape[1]))

from sklearn.metrics import mean_squared_error, mean_absolute_error

import numpy as np

# 예측값과 실제값 추출

predicted = model(df_x_ss).data.numpy()

actual = df_y_ms.data.numpy()

# inverse_transform으로 정규화된 값을 다시 변환

predicted = ms.inverse_transform(predicted)

actual = ms.inverse_transform(actual)

# MSE 계산

mse = mean_squared_error(actual, predicted)

print("Mean Squared Error (MSE):", mse)

# MAE 계산

mae = mean_absolute_error(actual, predicted)

print("Mean Absolute Error (MAE):", mae)

# RMSE 계산

rmse = np.sqrt(mse)

print("Root Mean Squared Error (RMSE):", rmse)

train_predict = model(df_x_ss)

predicted = train_predict.data.numpy()

label_y = df_y_ms.data.numpy()

predicted = ms.inverse_transform(predicted)

label_y = ms.inverse_transform(label_y)

plt.figure(figsize=(10, 6))

plt.axvline(x=datetime(2022,5,1), c='r', linestyle='--')

df['pred'] = predicted

plt.plot(df['Close'], label='Actual Data')

plt.plot(df['pred'], label='Predicted Data')

plt.title('Time-series Prediction')

plt.legend()

plt.show()

Pytorch - GRU를 사용한 숫자형 예측 코드

큐트아리 — Wed, 27 Mar 2024 00:03:23 +0900

import torch
import torch.nn
import torchvision.transforms as transforms
import torchvision.datasets
from torch.nn import Parameter
import torch.nn as nn
from torch import Tensor

import torch.nn.functional as F
from torch.utils.data import DataLoader
import math

import matplotlib.pyplot as plt
from datetime import datetime
import seaborn as sns

class GRU(nn.Module) :
    def __init__(self, num_classes, input_size, hidden_size, num_layers, seq_length) :
        super(GRU, self).__init__()
        self.num_classes = num_classes
        self.num_layers = num_layers
        self.input_size = input_size
        self.hidden_size = hidden_size
        self.seq_length = seq_length

        self.gru = nn.GRU(input_size=input_size,hidden_size=hidden_size,
                         num_layers=num_layers,batch_first=True)
        self.fc_1 = nn.Linear(hidden_size, 128)
        self.fc = nn.Linear(128, num_classes)
        self.relu = nn.ReLU()

    def forward(self, x) :
        h_0 = torch.zeros(self.num_layers, x.size(0), self.hidden_size)
        output, (hn) = self.gru(x, (h_0))
        hn = hn.view(-1, self.hidden_size)
        out = self.relu(hn)
        out = self.fc_1(out)
        out = self.relu(out)
        out = self.fc(out)
        return out
        
        plt.style.use('seaborn-whitegrid')

device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')

cuda = True if torch.cuda.is_available() else False
Tensor = torch.cuda.FloatTensor if cuda else torch.FloatTensor

# 난수 생성기의 시드(seed)를 설정
torch.manual_seed(125)

if torch.cuda.is_available() :
    torch.cuda.manual_seed_all(125)
import yfinance as yf
df = yf.download('005930.KS',
                     start='2022-01-01',
                     end='2022-05-31') # 005930 : 삼성전자 주가

df.head()

# data check
fig = df['Close'].plot()

X = df.drop('Close', axis=1) # X, y 분리
y = df[['Close']]

from sklearn.preprocessing import StandardScaler, MinMaxScaler

ms = MinMaxScaler() # 0 ~ 1
ss = StandardScaler() # 평균 0, 분산 1

X_ss = ss.fit_transform(X)
y_ms = ms.fit_transform(y)

X_train = X_ss[:79, :]
X_test = X_ss[79:, :]

y_train = y_ms[:79, :]
y_test = y_ms[79:, :]

print('Training Shape :', X_train.shape, y_train.shape)
print('Testing Shape :', X_test.shape, y_test.shape)

# 데이터셋 형태 및 크기 조정
X_train_tensors = torch.Tensor(X_train)
X_test_tensors = torch.Tensor(X_test)

y_train_tensors = torch.Tensor(y_train)
y_test_tensors = torch.Tensor(y_test)

X_train_tensors_f = torch.reshape(X_train_tensors, (X_train_tensors.shape[0], 1, X_train_tensors.shape[1]))

X_test_tensors_f = torch.reshape(X_test_tensors, (X_test_tensors.shape[0], 1, X_test_tensors.shape[1]))

print('Training Shape :', X_train.shape, y_train.shape)

X_train_tensors[0]
#tensor([ 1.9638,  2.0233,  2.0394,  2.0632, -0.0441])

X_train_tensors_f[0]

num_epochs = 1000
learning_rate = 0.0001

input_size=5
hidden_size=2
num_layers=1

num_classes=1

model=GRU(num_classes,input_size,hidden_size,num_layers,X_train_tensors_f.shape[1])

criterion = torch.nn.MSELoss()
optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)
# tensor([[ 1.9638,  2.0233,  2.0394,  2.0632, -0.0441]])

for epoch in range(num_epochs) :
    outputs = model.forward(X_train_tensors_f)
    optimizer.zero_grad()
    loss = criterion(outputs, y_train_tensors)
    loss.backward()

    optimizer.step()
    if epoch % 100 == 0 :
        print(f'Epoch : {epoch}, loss : {loss.item():1.5f}')
        
df_x_ss = ss.transform(X)
df_y_ms = ms.transform(y)

df_x_ss = torch.Tensor(df_x_ss)
df_y_ms = torch.Tensor(df_y_ms)
df_x_ss = torch.reshape(df_x_ss, (df_x_ss.shape[0], 1, df_x_ss.shape[1]))

from sklearn.metrics import mean_squared_error, mean_absolute_error
import numpy as np

# 예측값과 실제값 추출
predicted = model(df_x_ss).data.numpy()
actual = df_y_ms.data.numpy()

# inverse_transform으로 정규화된 값을 다시 변환
predicted = ms.inverse_transform(predicted)
actual = ms.inverse_transform(actual)

# MSE 계산
mse = mean_squared_error(actual, predicted)
print("Mean Squared Error (MSE):", mse)

# MAE 계산
mae = mean_absolute_error(actual, predicted)
print("Mean Absolute Error (MAE):", mae)

# RMSE 계산
rmse = np.sqrt(mse)
print("Root Mean Squared Error (RMSE):", rmse)

# Mean Squared Error (MSE): 2250454.0
# Mean Absolute Error (MAE): 1058.7194
# Root Mean Squared Error (RMSE): 1500.1514

train_predict = model(df_x_ss)
predicted = train_predict.data.numpy()

label_y = df_y_ms.data.numpy()

predicted = ms.inverse_transform(predicted)
label_y = ms.inverse_transform(label_y)
plt.figure(figsize=(10, 6))
plt.axvline(x=datetime(2022,5,1), c='r', linestyle='--')

df['pred'] = predicted
plt.plot(df['Close'], label='Actual Data')
plt.plot(df['pred'], label='Predicted Data')

plt.title('Time-series Prediction')
plt.legend()
plt.show()

EfficientNet-B4를 사용한 포켓몬 분류

큐트아리 — Tue, 26 Mar 2024 21:37:18 +0900

1. EfficientNet이란?

EfficientNet은 Neural Architecture Search (NAS)를 통해 찾아진 효율적이고 강력한 컨볼루션 신경망 구조입니다. EfficientNet은 모델의 성능과 효율성을 극대화하기 위해 네트워크의 깊이, 너비 및 해상도를 동시에 조정하는 Compound Scaling을 적용합니다.

EfficientNet 모델은 네트워크의 깊이, 너비 및 해상도를 조절하는 세 가지 스케일 요소를 사용하여 조정됩니다. 각 스케일 요소는 계수를 사용하여 특정 크기의 모델을 조정하고, 이러한 스케일 요소들은 서로 독립적으로 변환될 수 있습니다. 이것은 네트워크의 파라미터 수, 연산 비용 및 메모리 요구 사항을 최소화하면서 성능을 향상시키는 효과적인 방법을 제공합니다.

EfficientNet은 기본적으로 Depthwise Separable Convolution과 Swish 활성화 함수를 사용하여 경량화 및 성능 향상을 달성합니다. 이러한 구성 요소들은 모델의 파라미터 수를 줄이고 연산량을 감소시키면서도 효율적인 특징 추출을 가능하게 합니다.

EfficientNet의 여러 가지 버전들(EfficientNet-B0부터 B7까지)이 있으며, 각 버전은 네트워크의 크기를 조정하여 다양한 용도와 환경에 적합하도록 설계되었습니다. EfficientNet-B4는 그 중 하나로, 중간 크기의 모델로써 효율성과 성능 사이의 균형을 제공합니다.

요약하자면, EfficientNet은 파라미터와 연산량을 줄이면서도 높은 성능을 제공하는 효율적인 신경망 아키텍처입니다. EfficientNet-B4는 그 중 하나로 중간 크기의 모델이며, 다양한 컴퓨터 비전 작업에 유용하게 사용될 수 있습니다.

2. 포켓몬 분류

Train : https://www.kaggle.com/datasets/thedagger/pokemon-generation-one
Validation : https://www.kaggle.com/hlrhegemony/pokemon-image-dataset

두 파일의 포켓몬 종류가 서로 다름으로 나중에 맞춰줄 예정

import os

os.environ['KAGGLE_USERNAME'] = '아이디'

os.environ['KAGGLE_KEY'] = '본인APIKEY'

!kaggle datasets download -d thedagger/pokemon-generation-one

!kaggle datasets download -d hlrhegemony/pokemon-image-dataset

!unzip -q pokemon-generation-one.zip

!unzip -q pokemon-image-dataset.zip

# train 폴더 생성해서 dataset안의 파일을 train으로 이동

# !mv 현재폴더 이동폴더

!mv dataset train

!rm -rf train/dataset # 데이터가 중복되어 있음

# validation 폴더 생성해서 images안의 파일을 validation으로 이동

!mv images validation

train_labels = os.listdir('train')

print(len(train_labels))

# 149

폴더가 각각의 포켓몬 이름으로 구성되어 있음으로 폴더의 수는 포켓몬 수입니다.

즉, train에는 149종류의 포켓몬의 사진이 들어있습니다.

val_labels = os.listdir('validation')

print(len(val_labels))

# 898

validation에는 898종류의 포켓몬 사진이 들어있습니다.

둘이 맞지 않네요. train으로 학습시키지 않은 포켓몬을 validation에 넣어봤자겠죠.

# train : 149

# validation : 898

# validation에서 train에 있는 디렉토리를 확인하여 없는 디렉토리를 모두 제거

import shutil

# train에 있는데 validation에 없는 디렉토리 제거

for val_label in val_labels:

if val_label not in train_labels:

shutil.rmtree(os.path.join('validation',val_label))

train_labels = os.listdir('train')

print(len(train_labels))

validation_labels = os.listdir('validation')

print(len(validation_labels))

# 149

# 147

여전히 맞지 않네요. train에 있는 애들중에 validation에 없는 애들이 있다는 뜻입니다.

뭔지 확인하고 그 폴더를 생성해주겠습니다. 그리고 저 포켓몬에 맞는 사진을 몇개 인터넷에서 구해와서 직접 추가해주었습니다.

for train_label in train_labels:

if train_label not in val_labels:

print(train_label)

os.makedirs(os.path.join('validation', train_label), exist_ok=True)

# MrMime

# Farfetchd

데이터 전처리

# 필요한 모듈 준비

import torch

import torch.nn as nn

import torch.optim as optim

import matplotlib.pyplot as plt

from torchvision import datasets, models, transforms

from torch.utils.data import DataLoader

# GPU 사용 확인

device = 'cuda' if torch.cuda.is_available() else 'cpu'

print(device)

# 이미지 증강 기법

# data_transforms

# train / validation

data_transforms = {

# Compose : 데이터에 처리하고자하는 함수들을 한번에 처리해주는 기능

'train' : transforms.Compose([

transforms.Resize((224,224)),

# RandomAffine() : 데이터를 랜덤하게 뽑아서 변환시켜주겠다는 의미

# 각도 : 0(변환x), shear(찌그러트림) , acale : 변환된 이미지의 크기는 원본 이미지 크기의 80%에서 120% 사이에서 무작위로 선택

transforms.RandomAffine(0, shear =10, scale=(0.8,1.2)),

# RandomHorizontalFlip 이미지를 수평으로 뒤집기

transforms.RandomHorizontalFlip(),

transforms.ToTensor()

]),

'validation' : transforms.Compose([

transforms.Resize((224,224)),

transforms.ToTensor()

])

}

# 데이터셋 객체 생성

# Image_datasets

# train / validation

def target_transforms(target):

return torch.LongTensor([target])

# 데이터셋 객체 만들어서 가져와줌

image_datasets = {

'train' : datasets.ImageFolder(

'train', # 해당 위치의 파일에서

data_transforms['train'], # data_transforms의 train을 가져와서

target_transform = target_transforms # 이 함수 써줌(콜백함수 개념)

'validation' : datasets.ImageFolder(

'validation', # 해당 위치의 파일에서

data_transforms['validation'], # data_transforms의 train을 가져와서

target_transform = target_transforms # 이 함수 써줌(콜백함수 개념)

)

}

image_datasets['train']

# 데이터로더 생성

# dataloaders

# batch_size = 32

# shuffle = True

dataloaders = {

'train' : DataLoader(

image_datasets['train'],

batch_size=32,

shuffle=True

'validation': DataLoader(

image_datasets['validation'],

batch_size=32,

shuffle=False

)

}

print(len(image_datasets['train']),len(image_datasets['validation']))

# 10657 661

# 이미지 4*8로 출력

imgs, labels = next(iter(dataloaders['train']))

fig, axes = plt.subplots(4,8,figsize=(20,10))

for ax, img, label in zip(axes.flatten(), imgs, labels):

# 찍으려면 가로, 세로, 컬러 순서여야해서 permute 해줌

ax.imshow(img.permute(1,2,0))

ax.set_title(label)

ax.axis('off')

클래스 확인하는 법

102번 사진의 클래스 이름

image_datasets['train'].classes[101]

# Pikachu

imgs, labels = next(iter(dataloaders['validation']))

fig, axes = plt.subplots(4,8,figsize=(20,10))

for ax, img, label in zip(axes.flatten(), imgs, labels):

# 찍으려면 가로, 세로, 컬러 순서여야해서 permute 해줌

ax.imshow(img.permute(1,2,0))

ax.set_title(label)

ax.axis('off')

from torchvision.models import efficientnet_b4, EfficientNet_B4_Weights

from torchvision.models._api import WeightsEnum

from torch.hub import load_state_dict_from_url

# WeightsEnum.get_state_dict를 재정의

def get_state_dict(self, *args, **kwargs):

kwargs.pop("check_hash")

return load_state_dict_from_url(self.url, *args, **kwargs)

WeightsEnum.get_state_dict = get_state_dict

efficientnet_b4(weights=EfficientNet_B4_Weights.IMAGENET1K_V1)

model = efficientnet_b4(weights="DEFAULT").to(device)

# FX Layer 수정

for param in model.parameters():

param.requires_grad = False # 가져온 파라미터 (W, b)를 업데이트하지 않음

model.classifier = nn.Sequential(

nn.Linear(1792,1000),

nn.ReLU(),

nn.Linear(1000,len(val_labels)),

).to(device)

print(model)

# 학습

optimizer = optim.Adam(model.classifier.parameters(), lr=0.001)

epochs = 10

for epoch in range(epochs):

# 이렇게 되면 학습이 끝날때 모델이 자동으로 model.eval()가 된 상태로 나옴

for phase in ['train', 'validation']:

if phase == 'train':

model.train()

else:

model.eval()

sum_losses = 0

sum_accs = 0

for x_batch, y_batch in dataloaders[phase]:

x_batch, y_batch = x_batch.to(device), y_batch.to(device)

y_pred = model(x_batch)

# 보통 이런 다중분류의 출력값은 2차원임으로 1차원으로 줄여주고 정수형으로 변환

y_batch = torch.flatten(y_batch).long()

# 다중분류문제임으로 CrossEntropyLoss

# CrossEntropyLoss는 Softmax를 이미 포함하고 있음으로 무조건 Sigmoid해주던 이진분류와는 조금 다름

loss = nn.CrossEntropyLoss()(y_pred, y_batch)

if phase == 'train':

optimizer.zero_grad()

loss.backward()

optimizer.step()

sum_losses = sum_losses + loss

y_prob = nn.Softmax(1)(y_pred)

y_pred_index = torch.argmax(y_prob, axis=1)

acc = (y_batch == y_pred_index).float().sum() / len(y_batch) * 100

sum_accs = sum_accs + acc

avg_loss = sum_losses / len(dataloaders[phase])

avg_acc = sum_accs / len(dataloaders[phase])

print(f'{phase:10s}: Epoch {epoch+1:4d}/{epochs} Loss: {avg_loss:.4f} Accuracy: {avg_acc: .2f}%')

# 모델 저장

torch.save(model.state_dict(),'model.pth') # model.h5도 가능

모델 불러오기

# 학습이 안된 날것의 모델 불러오기

model = models.efficientnet_b4().to(device)

# FX Layer 수정

for param in model.parameters():

param.requires_grad = False # 가져온 파라미터 (W, b)를 업데이트하지 않음

model.classifier = nn.Sequential(

nn.Linear(1792,1000),

nn.ReLU(),

nn.Linear(1000,len(val_labels)),

).to(device)

# 모델 불러오기

model.load_state_dict(torch.load('model.pth'))

model.eval()

print(model)

모델평가

from PIL import Image

img1 = Image.open('./validation/Ditto/0.jpg')

img2 = Image.open('./validation/Charmander/0.jpg')

fig,axes = plt.subplots(1,2,figsize=(12,6))

axes[0].imshow(img1)

axes[0].axis('off') # 틀 안나오게

axes[1].imshow(img2)

axes[1].axis('off') # 틀 안나오게

plt.show()

이 귀여운 메타몽과 파이리를 모델에 넣어 어떤 결과가 나오는지 보겠습니다.

img1_input = data_transforms['validation'](img1)

img2_input = data_transforms['validation'](img2)

print(img1_input.shape,img2_input.shape)

# torch.Size([3, 224, 224]) torch.Size([3, 224, 224])

test_batch = torch.stack([img1_input,img2_input])

test_batch = test_batch.to(device)

test_batch.shape

# torch.Size([2, 3, 224, 224])

y_pred = model(test_batch)

y_prob = nn.Softmax(1)(y_pred)

y_pred_index = torch.argmax(y_prob, axis=1)

# 상위 3개 값을 얻기

topk_values, topk_indices = torch.topk(y_prob, k=3, dim=1)

title_list = []

for i in range(2):

title = ''

for j in range(3):

title += f"{image_datasets['validation'].classes[topk_indices[i][j]]}:{topk_values[i][j] * 100:.2f}% "

title_list.append(title)

fig,axes = plt.subplots(1,2,figsize=(12,6))

axes[0].imshow(img1)

axes[0].axis('off') # 틀 안나오게

axes[0].set_title(title_list[0])

axes[1].imshow(img2)

axes[1].axis('off') # 틀 안나오게

axes[1].set_title(title_list[1])

plt.show()

# topk_indices

아주 잘나오네요.

이번엔 저희집 고양이 아리를 넣어보겠습니다.

my_img = Image.open('/content/KakaoTalk_20240112_102619252.jpg')

my_img_input = data_transforms['validation'](my_img)

my_batch = torch.stack([my_img_input])

my_batch = my_batch.to(device)

my_pred = model(my_batch)

my_prob = nn.Softmax(1)(my_pred)

val, idx = torch.topk(my_prob, 3)

fig, axes = plt.subplots(1, 2, figsize=(15, 6))

axes[0].imshow(my_img)

axes[0].axis('off')

axes[1].set_title('{:2f}% {}, {:2f}% {}, {:2f}% {}'.format(

val[0, 0] * 100,

image_datasets['validation'].classes[idx[0, 0]],

val[0, 1] * 100,

image_datasets['validation'].classes[idx[0, 1]],

val[0, 2] * 100,

image_datasets['validation'].classes[idx[0, 2]],

))

src = image_datasets['validation'].classes[idx[0, 1]]

i = Image.open(f'validation/{src}/0.jpg')

axes[1].imshow(i)

axes[1].axis('off')

plt.show()

오.... 컬러도 그렇고 좀 닮은것같네요 귀엽네요...

이렇게 EfficientNet-B4를 사용해서 이미지 분류를 해보았습니다.

ResNet50를 사용하여 이미지 분류

큐트아리 — Tue, 26 Mar 2024 19:24:11 +0900

우선, 케글에서 데이터셋을 받아옵니다.

에일리언 vs 프레데터 데이터셋

https://www.kaggle.com/datasets/pmigdal/alien-vs-predator-images

케글 데이터를 바로 받아오는 법

케글 로그인 _> 우측 상단 계정 클릭 -> Your Profile -> API New Create Token -> kaggle.json다운
{"username":"본인의 아이디","key":"본인api키"}
원하는 데이터의 COPY API COMMAND 한걸 !달아서 실행

import os

os.environ['KAGGLE_USERNAME'] = '아이디'

os.environ['KAGGLE_KEY'] = 'API키'

!kaggle datasets download -d pmigdal/alien-vs-predator-images

이렇게 되면 zip파일로 받아와지는데 zip파일을 압축 해제하는 것도 코드로 가능합니다.

!unzip -q alien-vs-predator-images.zip

이제 모델을 돌리기 위해 데이터 정제를 하겠습니다.

import torch

import torch.nn as nn

import torch.optim as optim

import matplotlib.pyplot as plt

from torchvision import datasets, models, transforms

from torch.utils.data import DataLoader

device = 'cuda' if torch.cuda.is_available() else 'cpu'

print(device)

이미지 증강 기법(Image Augmentation)

원본 이미지 데이터를 조작하려 원본과는 다른 변화를 가진 이미지를 생성
일반적으로 모델 성능이 좋아짐
오버피팅을 방지

https://pytorch.org/vision/master/transforms.html

이때, train의 데이터만 증강을 거치고 test는 증강을 하지 않음으로 이 둘을 나눠서 작성해줍니다

data_transforms = {

# Compose : 데이터에 처리하고자하는 함수들을 한번에 처리해주는 기능

'train' : transforms.Compose([

transforms.Resize((224,224)),

# RandomAffine() : 데이터를 랜덤하게 뽑아서 변환시켜주겠다는 의미

# 각도 : 0(변환x), shear(찌그러트림) , acale : 변환된 이미지의 크기는 원본 이미지 크기의 80%에서 120% 사이에서 무작위로 선택

transforms.RandomAffine(0, shear =10, scale=(0.8,1.2)),

# RandomHorizontalFlip 이미지를 수평으로 뒤집기

transforms.RandomHorizontalFlip(),

transforms.ToTensor()

]),

'validation' : transforms.Compose([

transforms.Resize((224,224)),

transforms.ToTensor()

])

}

보통 분류문제에서는 LongTensor를 사용하나 이진분류의 경우 손실함수를 Binary Cross Entropy Loss로 사용합니다. 때문에, LongTensor로 Y값을 정할 경우 에러가 나게 됨으로 이진분류시 target은 FloatTensor로 설정하면 됩니다

def target_transforms(target):

return torch.FloatTensor([target])

이터셋 객체 만들어서 가져와줌

# 이렇게 할 경우, 폴더에서 파일을 불러오면서 transform을 통해 증강 및 resize와 같은 전처리를 할 수 있음

image_datasets = {

'train' : datasets.ImageFolder(

root='data/train', # 데이터셋의 루트 디렉토리

transform = data_transforms['train'], # 이미지에 적용할 변환

target_transform=target_transforms # 레이블에 적용할 변환

'validation' : datasets.ImageFolder(

'data/validation', # 해당 위치의 파일에서

transform = data_transforms['validation'], # data_transforms의 train을 가져와서

target_transform = target_transforms # 이 함수 써줌(콜백함수 개념)

)

}

# 데이터 불러오는 것이 끝났으니 DataLoader로 데이터를 배치별로 묶어줍니다

dataloaders = {

'train' : DataLoader(

image_datasets['train'],

batch_size=32,

shuffle=True

'validation': DataLoader(

image_datasets['validation'],

batch_size=32,

shuffle=False

)

}

print(len(image_datasets['train']),len(image_datasets['validation']))

# 694 200

imgs, labels = next(iter(dataloaders['train']))

fig, axes = plt.subplots(4,8,figsize=(16,8))

for ax, img, label in zip(axes.flatten(), imgs, labels):

# 찍으려면 가로, 세로, 컬러 순서여야해서 permute 해줌

ax.imshow(img.permute(1,2,0))

ax.set_title(label.item())

ax.axis('off')

사실 전 영화를 잘 안봐서 predator가 뭔지 잘 모릅니다. 위의 사진을 보고도 구분하기 어렵네요. 하지만 데이터가 있으니 학습을 시켜 저 대신에 모델이 구분할 수 있도록 만들어보겠습니다.

ResNet50 불러오기

model = models.resnet50(weights='IMAGENET1K_V1').to(device)

print(model)

for param in model.parameters():

param.requires_grad = False # 가져온 파라미터 (W, b)를 업데이트하지 않음

model.fc = nn.Sequential(

nn.Linear(2048,128),

nn.ReLU(),

nn.Linear(128,1), # 이진분류니까 1

nn.Sigmoid()

).to(device)

print(model)

이렇게 모델을 프린트하면 엄청나게 복잡하고 층층이 쌓인 모델 구조를 볼 수 있는데요. 이 모델은 다른 데이터로 이미 학습된 전이학습 모델이기에 그냥 써서는 우리가 원하는 분류를 할 수 없습니다.

모델 구조 맨 아래를 보시면 fc라고 보이지죠 거기가 저희가 입맛대로, 데이터대로 고쳐야하는 곳입니다.

지금은 2048이 들어와 1000개의 아웃풋으로 나오는데 2048은 모델의 피처맵수이고 1000은 이 모델이 최종적으로 1000개의 데이터를 구분할 수 있다는 뜻입니다.

하지만 우리는 이제 외계인과 수호자를 구분하니 저 곳의 아웃풋을 1로 만들어줘야 합니다.

2048개의 특징을 가지고 바로 이진분류를 하면 오류가 많이 생길 수 있고 성능이 잘 안나올 수 있으니 한줄한줄 줄여가면서 만들어보겠습니다.

모델 수정

5. Freeze Layers

특징을 Qhqdksosms CNN의 앞쪽 컨볼루션 레이어들은 학습을하지 않도록 설정
출력부분의 레이어(fc)를 다시 설정하며 분류에 맞게 변경

for param in model.parameters():

param.requires_grad = False # 가져온 파라미터 (W, b)를 업데이트하지 않음

model.fc = nn.Sequential(

nn.Linear(2048,128),

nn.ReLU(),

nn.Linear(128,1), # 이진분류니까 1

# 이진분류니까 Sigmoid 사용 사실 여기가 아니라 모델 밖에서 사용해도됨

nn.Sigmoid()

).to(device)

print(model)

이제 모델이 저희 데이터에 맞는 출력값을 뱉어낼 수 있게 되었습니다.

# 학습

optimizer = optim.Adam(model.fc.parameters(), lr=0.001)

epochs = 10

for epoch in range(epochs):

# 이렇게 되면 학습이 끝날때 모델이 자동으로 model.eval()가 된 상태로 나옴

for phase in ['train', 'validation']:

if phase == 'train':

model.train()

else:

model.eval()

sum_losses = 0

sum_accs = 0

for x_batch, y_batch in dataloaders[phase]:

x_batch = x_batch.to(device)

y_batch = y_batch.to(device)

y_pred = model(x_batch)

loss = nn.BCELoss()(y_pred, y_batch)

if phase == 'train':

optimizer.zero_grad()

loss.backward()

optimizer.step()

sum_losses = sum_losses + loss

y_bool = (y_pred >= 0.5).float()

acc = (y_batch == y_bool).float().sum() / len(y_batch) * 100

sum_accs = sum_accs + acc

avg_loss = sum_losses / len(dataloaders[phase])

avg_acc = sum_accs / len(dataloaders[phase])

print(f'{phase:10s}: Epoch {epoch+1:4d}/{epochs} Loss: {avg_loss:.4f} Accuracy: {avg_acc: .2f}%')

※참고 : 이미지데이터 열기

from PIL import Image

img1 = Image.open('./data/validation/alien/19.jpg')

img2 = Image.open('./data/validation/predator/20.jpg')

fig, axes = plt.subplots(1,2,figsize=(12,6))

axes[0].imshow(img1)

axes[0].axis('off')

axes[1].imshow(img2)

axes[1].axis('off')

plt.show()

# data_transforms는 내가 위에서 설정한 애로 사이즈 224,224로 재설정하고 텐서형태로 변환되어있음

# 그럼으로 새로 불러온 img1과 img2 둘다 같은 전처리를 거쳐야함

# data_transforms에는 Compose클래스가 가진 __call__이라는 스페셜 메서드가 있음으로 함수로 정하지 않았지만 ()를 붙여서 이미지를 넣으면 함수처럼 이미지가 data_transforms안에 설정된 것들이 적용됨

img1_input = data_transforms['validation'](img1)

img2_input = data_transforms['validation'](img2)

print(img1_input.shape,img2_input.shape)

# torch.Size([3, 224, 224]) torch.Size([3, 224, 224])

# 배치로 묶어서 모델에 연결

# 2,3,224,224 차원으로 img1_input와 img2_input를 쌓음

# stack : 차원을 쌓아주는 함수

test_batch = torch.stack([img1_input,img2_input])

test_batch = test_batch.to(device)

test_batch.shape

torch.Size([2, 3, 224, 224])

y_pred = model(test_batch)

y_pred

tensor([[0.1115],
        [0.9516]], device='cuda:0', grad_fn=<SigmoidBackward0>)

fig, axes = plt.subplots(1, 2, figsize=(12, 6))

axes[0].set_title(f'{(1-y_pred[0, 0])*100:.2f}% Alien, {(y_pred[0, 0])*100:.2f}% Predator')

axes[0].imshow(img1)

axes[0].axis('off')

axes[1].set_title(f'{(1-y_pred[1, 0])*100:.2f}% Alien, {(y_pred[1, 0])*100:.2f}% Predator')

axes[1].imshow(img2)

axes[1].axis('off')

plt.show()

전이 학습

큐트아리 — Tue, 26 Mar 2024 18:26:35 +0900

전이 학습(Transfer Learning)

하나의 작업을 위해 훈련된 모델을 유사 작업 수행 모델의 시작점으로 활용하는 딥러닝 접근법
신경망은 처음부터 새로 학습하는 것보다 전이 학습을 통해 업데이트하고 재학습하는 편이 더 빠르고 간편함
전이 학습 방법은 여러 응용분야(검출, 영상인식, 음성인식, 검색 등)에서 많이 사용

1. 전이 학습의 고려할 점

크기 : 모델 크기는 배포할 위치와 방법에 따라 달라질 수 있음
속도 및 정확도 : 하드웨어, 배치크기와 같은 요소를 고려해야한다
정확도와 GPU 사용량등을 고려하여 적절히 사용
동그라미 크기는 파라미터 개수, 덩치가 큰 애들은 CPU, GPU가 많이 쓰이지만 학습량이 많음

2. 사전 학습된 ResNet50 모델 사용하기

파이토치에서 제공하는 사전학습 모델들

3. 이미지넷(ImageNet)

이미지 데이터 베이스
1000개의 클래스로 동물과 사물 이미지를 포함