부정확하거나 일관되지 않은 라벨:

• 라벨의 오류는 모델의 성능을 저하시킬 수 있습니다. 모델이 잘못된 라벨을 학습하면, 정확성, 정밀도, 재현율과 같은 성능 지표가 모두 감소하게 됩니다.

왜곡된 라벨링:

• 라벨이 실제 시나리오를 제대로 대표하지 못할 경우, 모델은 새로운 데이터에 대해 일반화하지 못할 위험이 있습니다. 이는 모델이 실제 환경에서 예측 성능이 떨어지게 만드는 주요 원인이 됩니다.

비용 문제:

• 모델 학습 후에 잘못된 라벨을 수정하는 것은 많은 시간과 계산 리소스를 필요로 합니다. 사전에 정확한 라벨링을 보장하는 것이 훨씬 더 비용 효율적입니다.

편향 문제:

• 일관되지 않거나 부정확한 라벨링은 모델에 편향을 초래할 수 있습니다. 이는 특정 그룹이나 시나리오에 대해 모델이 불공평하거나 비효율적인 결정을 내리는 결과를 초래할 수 있습니다.

디버깅 어려움:

• 라벨링 오류는 모델 디버깅을 더 어렵게 만듭니다. 성능 저하가 모델 아키텍처, 하이퍼파라미터, 혹은 데이터 자체의 문제로 인한 것인지 구별하기가 힘들어질 수 있습니다.

신뢰성:

• 기계 학습 모델의 신뢰성과 효율성은 사용자 신뢰에 매우 중요합니다. 잘못된 라벨이 포함된 데이터는 특히 의료, 금융, 또는 안전이 중요한 시스템에서 모델의 신뢰성을 크게 약화시킬 수 있습니다.

라이브러리 import

import pandas as pd
import numpy as np
from tqdm import tqdm
from glob import glob
from typing import *
from IPython.display import Image as IPImage
from sklearn.model_selection import train_test_split
import random
import os
import shutil
from PIL import Image as Image
import torch
import torch.nn as nn
import torch.optim as optim
from torchvision import datasets, models, transforms
from torch.utils.data import DataLoader, Dataset
from torch.utils.data import ConcatDataset
from sklearn.metrics import confusion_matrix, accuracy_score, f1_score
import seaborn as sns
import matplotlib.pyplot as plt
from torchvision.transforms import functional as F

# 코랩에서 GPU 사용을 위해서는 별도의 설정이 필요합니다.
# 상단 런타임 -> 런타임 유형 변경의 항목을 통해 CPU대신 사용 가능한 GPU로 하드웨어 가속기를 변경해줍니다.
# 아래 코드는 GPU 사용이 가능한 상태인지 확인하는 코드로, 올바르게 GPU 설정이 되어있다면 TURE, 1이 출력됩니다.
print(torch.cuda.is_available())
print(torch.cuda.device_count())

True
1

GPU 환경 설정

# nivida-smi 명령어를 통해 할당된 GPU의 정보에 대해 확인할 수 있습니다.
!nvidia-smi

Wed Nov 29 07:59:40 2023       
+-----------------------------------------------------------------------------+
| NVIDIA-SMI 450.80.02    Driver Version: 450.80.02    CUDA Version: 11.2     |
|-------------------------------+----------------------+----------------------+
| GPU  Name        Persistence-M| Bus-Id        Disp.A | Volatile Uncorr. ECC |
| Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |
|                               |                      |               MIG M. |
|===============================+======================+======================|
|   0  Tesla V100-DGXS...  On   | 00000000:0F:00.0 Off |                    0 |
| N/A   39C    P0    37W / 300W |     14MiB / 32508MiB |      0%      Default |
|                               |                      |                  N/A |
+-------------------------------+----------------------+----------------------+

+-----------------------------------------------------------------------------+
| Processes:                                                                  |
|  GPU   GI   CI        PID   Type   Process name                  GPU Memory |
|        ID   ID                                                   Usage      |
|=============================================================================|
+-----------------------------------------------------------------------------+

랜덤시드 고정

def seed_everything(seed):
    random.seed(seed)  # Python
    np.random.seed(seed)  # NumPy
    torch.manual_seed(seed)  # PyTorch
    torch.cuda.manual_seed(seed)  # PyTorch cuda
    torch.backends.cudnn.deterministic = True  # CuDNN
    torch.backends.cudnn.benchmark = False  # CuDNN benchmark

seed_everything(seed=32)

Google Colab에서 데이터 관리 및 최적 활용 전략

드라이브 설정

• 코랩에서 데이터에 접근하는 방법에는 크게 두 가지가 있습니다.

  • 1. 구글 드라이브 연동 : 자신의 Google Drive를 코랩에 연결하여 드라이브 안의 데이터에 접근합니다.
  • 2. 코랩의 세션 드라이브 업로드 : 코랩의 임시 저장 공간에 데이터를 업로드하여 사용합니다.

• 각각의 방법은 장단점을 가지고 있습니다.

• 구글 드라이브 연동의 장점은 드라이브에 데이터가 미리 준비되어 있으면 즉시 사용할 수 있다는 것이며, 데이터가 지속적으로 보존됩니다. 단점은 이미지 데이터와 같이 용량이 큰 데이터를 다룰 때, 로딩 속도가 매우 느리다는 단점이 있습니다.

• 코랩의 세션 드라이브에 업로드하는 방법의 장점은 드라이브 연동에 비해 로딩 속도를 매우 빠르게 사용할 수 있다는 것입니다. 하지만 이 방법의 단점은 코랩 런타임이 초기화될 때마다 데이터가 사라지고, 다른 ipynb에서 접근이 안된다는 단점이 존재합니다.

• 따라서 이미지 데이터와 같이 대용량의 학습 데이터는 학습 직전에 임시 경로에 업로드하여 사용하고, 그 외 필요한 파일들은 구글 드라이브에서 직접 불러오는 것이 좋습니다. 또한 학습된 모델 파일처럼 저장이 필요한 자료는 보존을 위해 반드시 구글 드라이브에 저장합니다. 이렇게 하면 데이터 사용의 효율성과 접근성을 극대화할 수 있습니다.

데이터셋 로드

# 작업 환경의 현재 경로를 확인합니다.
os.getcwd()

'/content'

코랩의 세션 드라이브에 데이터 업로드

import gdown

# Google Drive 파일 ID와 URL 설정
file_id = "1U7vCDZ4X9ElceQvBllL8ccGHXHjc1qTw"
url = f"https://drive.google.com/uc?id={file_id}"

# 다운로드할 파일 이름 설정
output = "OCR_ResNet18_dataset.zip"

# gdown을 사용하여 파일 다운로드
gdown.download(url, output, quiet=False)

print(f"파일 다운로드가 완료되었습니다: {output}")

Downloading...
From (original): https://drive.google.com/uc?id=1U7vCDZ4X9ElceQvBllL8ccGHXHjc1qTw
From (redirected): https://drive.google.com/uc?id=1U7vCDZ4X9ElceQvBllL8ccGHXHjc1qTw&confirm=t&uuid=213ebd5e-b908-4884-a0fc-fcc4cf26a37d
To: /content/OCR_ResNet18_dataset.zip
100%|██████████| 82.9M/82.9M [00:00<00:00, 171MB/s]


파일 다운로드가 완료되었습니다: OCR_ResNet18_dataset.zip

# unzip 명령어를 통해 압축 파일을 해제해 줍니다.
!unzip -qq OCR_ResNet18_dataset.zip

# 코랩 드라이브에서 대량의 이미지 파일을 로드할 경우 매우 시간이 오래 걸립니다.
# 따라서 사용할 이미지는 drive 경로(/content/drive)가 아닌 코랩 세션 드라이브(/content/drive 이외의 경로)의 경로에 데이터를 업로드해줍니다.
image_path = "./dataset/digit_data"
asset_path = "./assets"

# 학습 데이터셋
origin_train_df = pd.read_csv(f"{image_path}/train_data.txt", names=["path"])
origin_train_df["label"] = origin_train_df["path"].str[0].astype(int)
origin_train_df["path"] = image_path + "/" + origin_train_df["path"]
origin_train_df

# 테스트 데이터셋 (valid_data.txt지만 미리 나눠진 test set으로 사용하도록 하겠음)
test_df = pd.read_csv(f"{image_path}/valid_data.txt", names=["path"])
test_df["label"] = test_df["path"].str[0].astype(int)
test_df["path"] = image_path + "/" + test_df["path"]
test_df

Train/Valid/Test 데이터셋 분리

kamp데이터는 train/valid 밖에 구분되어 있지 않지만

저희는 보다 명확한 검토를 위해

train => train/valid

valid = > test

로 사용하도록 하겠습니다

# train 데이터셋을 8:2로 나눠서 valid를 하도록 하겠습니다
train_df, valid_df = train_test_split(
    origin_train_df,
    test_size=0.2,
    random_state=0,
    shuffle=True,
    stratify=origin_train_df["label"],
)

DataSet, DataLoader 생성

PyTorch에서 torch.utils.data.Dataset 클래스를 사용하는 이유:

1. 데이터 관리의 일관성 Dataset 클래스를 사용하면 데이터를 일관된 방식으로 관리할 수 있습니다. 데이터 로드, 전처리, 샘플링을 위한 구조를 명확히 정의할 수 있어 코드 유지보수가 용이합니다. raw 데이터를 직접 사용하면 데이터를 불러오는 로직이 코드 곳곳에 흩어질 수 있습니다. Dataset 클래스는 데이터 관련 로직을 캡슐화하여 재사용성을 높이고 코드 가독성을 향상시킵니다.

2. 효율적인 데이터 로드 Dataset 클래스는 DataLoader와 함께 사용되어 배치 처리 및 병렬 데이터 로드를 지원합니다.raw 데이터를 직접 사용하면 배치 처리를 수동으로 구현해야 하며, 효율적이지 않을 수 있습니다. DataLoader는 Dataset에서 배치를 자동으로 생성하고, 멀티스레딩을 통해 데이터 로드 속도를 높입니다.

3. 동적인 데이터 전처리 Dataset 클래스의 핵심은 getitem과 len 메서드를 커스터마이징할 수 있다는 점입니다. 데이터를 로드하는 동시에 필요한 전처리(예: 텍스트 토크나이징, 이미지 변환 등)를 수행할 수 있습니다. raw 데이터를 직접 사용하면 데이터 전처리를 별도의 단계에서 처리해야 하므로 유연성이 떨어집니다.

4. 메모리 관리 Dataset은 필요할 때 데이터를 로드하는 방식을 지원합니다(예: Lazy Loading). raw 데이터를 한꺼번에 메모리에 올리면 큰 데이터셋의 경우 메모리 부족 문제가 발생할 수 있습니다. Dataset 클래스는 데이터를 필요할 때만 로드하거나 스트리밍 방식으로 처리하여 메모리 사용량을 최소화할 수 있습니다.

5. 확장성 사용자가 직접 데이터 구조를 정의하고 커스터마이징할 수 있습니다. raw 데이터는 구조적으로 고정되어 있어 추가적인 기능(예: 샘플링, 데이터 증강 등)을 구현하기 어렵습니다. Dataset을 상속받아 자신만의 데이터셋 클래스를 만들어 다양한 데이터 소스와 처리 방법을 통합할 수 있습니다.

# 사용자 정의 데이터셋 클래스 생성 (CustomDataset)
class CustomDataset(Dataset):
    def __init__(self, dataframe, transform=None):
        # 데이터셋 초기화
        # dataframe: 이미지 경로와 레이블이 포함된 데이터프레임
        # transform: 이미지에 적용할 전처리(transform) 함수
        self.dataframe = dataframe
        self.transform = transform

    def __len__(self):
        # 데이터셋의 총 샘플 수 반환
        return len(self.dataframe)

    def __getitem__(self, idx):
        # 주어진 인덱스(idx)에 해당하는 샘플을 반환
        # 이미지 경로를 데이터프레임에서 가져옴
        img_name = self.dataframe.iloc[idx, 0]
        # 이미지 파일을 열고 RGB 모드로 변환
        img = Image.open(img_name).convert('RGB')
        # 레이블 정보를 정수형으로 가져옴
        label = int(self.dataframe.iloc[idx, 1])

        # transform이 지정되어 있다면 이미지에 전처리를 적용
        if self.transform:
            img = self.transform(img)

        # 이미지와 레이블을 반환
        return img, label

'''
아래는 이미지 데이터셋의 각 RGB 채널에 대해 전체적인 평균(mean)과 표준 편차(standard deviation, std)를 계산하는 코드입니다.
이 작업은 데이터 전처리 과정에서 매우 중요한데, 다음과 같은 목적이 있습니다.

데이터 정규화 (Normalization): 딥러닝 모델에서 이미지를 입력으로 사용할 때, 입력 데이터의 스케일링을 동일하게 하는 것이 중요합니다.
각 픽셀 값에서 채널별 평균을 빼고, 표준 편차로 나누어서 픽셀 값의 분포를 정규화할 수 있습니다.
이렇게 함으로써 모델은 더 빠르게 수렴할 수 있고, 다른 데이터셋에 대한 모델의 일반화 능력을 향상시킬 수 있습니다.

데이터 표준화 (Standardization):
데이터셋에 있는 이미지들이 서로 다른 출처에서 오거나 다양한 조명 환경에서 촬영된 경우, 픽셀 값의 분포가 다를 수 있습니다.
표준화 과정을 거치면 이러한 차이를 줄여 모델이 이미지의 구조적인 특성에 더 집중할 수 있게 해줍니다.

모델 입력 요구사항 충족:
많은 딥러닝 모델들, 특히 사전 훈련된 네트워크는 특정 범위의 입력 값을 요구합니다.
예를 들어, 일부 모델은 입력 값으로 0에서 1 사이, 또는 -1에서 1 사이의 값을 요구할 수 있는데,
평균과 표준 편차를 계산하면 이러한 요구사항을 충족시키는 정규화 과정을 쉽게 적용할 수 있습니다.

하지만 해당 코드를 직접 실행하면, 매우 많은 연산량으로 인해 코랩 환경이 다운될 가능성이 높습니다.
보다 좋은 환경에서 직접 실행해 보고, 본 과정에서는 미리 계산된 값으로 이를 대체하겠습니다.
'''

def compute_overall_mean_std(dfs):
    all_pixels = {0: [], 1: [], 2: []}

    for df in dfs:
        for index, row in df.iterrows():
            img_path = row['path']  # 'path' 대신에 실제 경로가 있는 컬럼명을 사용해주세요.
            img = Image.open(img_path)
            img_np = np.array(img)

            for i in range(3): # RGB 채널
                channel_pixels = img_np[:, :, i].ravel().tolist()  # 각 채널의 모든 픽셀 값을 수집합니다.
                all_pixels[i].extend(channel_pixels)

    means = [np.mean(all_pixels[i]) for i in range(3)]
    stds = [np.std(all_pixels[i]) for i in range(3)]

    return means, stds


# train_df와 valid_df에 대해서 계산
# 컴퓨팅 자원이 풍부한 환경에서 실행할 경우 직접 실행해볼 수 있습니다.
# channel_means, channel_stds = compute_overall_mean_std([train_df, valid_df])

# 연산량 이슈로 미리 계산해둔 값 사용
channel_means = [193.67807472479592, 111.60517909723688, 118.44033090803525]
channel_stds = [63.00208387441839, 87.1299016633704, 71.00312754293988]

print("Overall Data: Mean -", channel_means, "Std -", channel_stds)

Overall Data: Mean - [193.67807472479592, 111.60517909723688, 118.44033090803525] Std - [63.00208387441839, 87.1299016633704, 71.00312754293988]

# 채널 평균 및 표준편차를 0~1 사이의 값으로 정규화
normalized_channel_means = [x / 255 for x in channel_means]
normalized_channel_stds = [x / 255 for x in channel_stds]

# 이미지 전처리를 위한 변환 작업 정의.
# transforms.Normalize 이전에 이미 픽셀값은 0~1 사이로 정규화 되어 있습니다.
# 따라서 기존의 0~255 픽셀값 기준에서 도출된 channel_means, channel_stds 도 0~1 사이 값으로 정규화 된 normalized_channel_means, normalized_channel_stds 로 변환하여 사용합니다
transform = transforms.Compose([
    transforms.Resize((224, 224)),
    transforms.ToTensor(),
    transforms.Normalize(mean=normalized_channel_means, std=normalized_channel_stds),
])

# 코랩의 GPU 환경은 실행시마다 바뀔 수 있습니다.
# 혹시 메모리 에러가 난다면 batch size를 줄여서 학습을 시도해 볼 수 있습니다.
batch_size = 256

# 데이터셋 로딩
train_dataset = CustomDataset(dataframe=train_df, transform=transform)
valid_dataset = CustomDataset(dataframe=valid_df, transform=transform)
test_dataset = CustomDataset(dataframe=test_df, transform=transform)

# 데이터 로더 설정
train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True, num_workers=4)
valid_loader = DataLoader(valid_dataset, batch_size=batch_size, shuffle=False, num_workers=4)
test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False, num_workers=4)

/usr/local/lib/python3.10/dist-packages/torch/utils/data/dataloader.py:557: UserWarning: This DataLoader will create 4 worker processes in total. Our suggested max number of worker in current system is 2, which is smaller than what this DataLoader is going to create. Please be aware that excessive worker creation might get DataLoader running slow or even freeze, lower the worker number to avoid potential slowness/freeze if necessary.
  warnings.warn(_create_warning_msg(

ResNet 모델 학습

# 사전 학습된 ResNet18 모델 불러오기
model = models.resnet18(pretrained=True)

# 모델의 마지막 완전 연결 계층(fc)을 사용자 정의 계층으로 대체
# 이 계층은 in_features에서 10개의 출력으로 매핑합니다 (10개 클래스 분류를 위함)
model.fc = nn.Sequential(
    nn.Linear(model.fc.in_features, 10),
)

# 교차 엔트로피 손실 함수 초기화
criterion = nn.CrossEntropyLoss()
# 최적화 알고리즘으로 Adam 사용
optimizer = torch.optim.Adam(model.parameters(), lr=1e-5, weight_decay=1e-5)

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = model.to(device)

/usr/local/lib/python3.10/dist-packages/torchvision/models/_utils.py:208: UserWarning: The parameter 'pretrained' is deprecated since 0.13 and may be removed in the future, please use 'weights' instead.
  warnings.warn(
/usr/local/lib/python3.10/dist-packages/torchvision/models/_utils.py:223: UserWarning: Arguments other than a weight enum or `None` for 'weights' are deprecated since 0.13 and may be removed in the future. The current behavior is equivalent to passing `weights=ResNet18_Weights.IMAGENET1K_V1`. You can also use `weights=ResNet18_Weights.DEFAULT` to get the most up-to-date weights.
  warnings.warn(msg)
Downloading: "https://download.pytorch.org/models/resnet18-f37072fd.pth" to /root/.cache/torch/hub/checkpoints/resnet18-f37072fd.pth
100%|██████████| 44.7M/44.7M [00:00<00:00, 137MB/s]

# 학습 파라미터 설정
num_epochs = 50  # 학습 반복 횟수
best_val_acc = 0.0  # 최상의 검증 정확도를 저장하는 변수
patience = 5  # 얼리 스탑핑을 위한 patience 설정 (개선되지 않은 횟수)
no_improve = 0  # 개선되지 않은 에포크 수를 카운트하는 변수

for epoch in range(num_epochs):

    # 모델을 학습 모드로 전환
    model.train()
    running_loss = 0.0  # 에포크 동안의 총 손실을 저장하는 변수
    correct_train = 0  # 정확하게 예측한 학습 데이터의 개수를 저장하는 변수
    total_train = 0  # 총 학습 데이터 개수를 저장하는 변수

    # 학습 데이터를 반복하여 모델 업데이트
    for inputs, labels in tqdm(train_loader, desc=f"Epoch {epoch+1}/{num_epochs}", dynamic_ncols=True):
        # 데이터를 장치로 이동 (GPU 또는 CPU)
        inputs, labels = inputs.to(device), labels.to(device)

        # 옵티마이저의 기울기 초기화
        optimizer.zero_grad()
        # 모델에 입력을 전달하여 예측값 출력
        outputs = model(inputs)
        # 손실 함수 계산
        loss = criterion(outputs, labels)
        # 손실에 대한 역전파 수행 (기울기 계산)
        loss.backward()
        # 옵티마이저를 통해 모델 파라미터 업데이
        optimizer.step()
        # 현재 배치의 손실을 누적
        running_loss += loss.item()

        # 정확도 계산을 위한 예측값 처리
        _, predicted = torch.max(outputs.data, 1) # 최대값을 가지는 클래스 예측
        total_train += labels.size(0) # 총 학습 데이터 수 누적
        correct_train += (predicted == labels).sum().item() # 맞춘 예측의 개수 누적

    # 에포크별 학습 정확도와 손실 계산
    train_acc = correct_train / total_train
    train_loss = running_loss / len(train_loader)

    # Validate
    model.eval()  # 모델을 평가 모드로 전환 (드롭아웃, 배치 정규화 등 비활성화)
    running_val_loss = 0.0  # 검증 손실을 저장하는 변수
    correct_val = 0  # 정확하게 예측한 검증 데이터의 개수를 저장하는 변수
    total_val = 0  # 총 검증 데이터 개수를 저장하는 변수
    with torch.no_grad(): # 검증 시에는 기울기를 계산하지 않음 (메모리 및 계산량 절약)
        for inputs, labels in valid_loader:
            # 데이터를 장치로 이동
            inputs, labels = inputs.to(device), labels.to(device)
            # 모델에 입력을 전달하여 예측값 출력
            outputs = model(inputs)
            # 손실 함수 계산
            loss = criterion(outputs, labels)
            # 현재 배치의 손실을 누적
            running_val_loss += loss.item()

            # 정확도 계산을 위한 예측값 처리
            _, predicted = torch.max(outputs.data, 1)  # 최대값을 가지는 클래스 예측
            total_val += labels.size(0)  # 총 검증 데이터 수 누적
            correct_val += (predicted == labels).sum().item()  # 맞춘 예측의 개수 누적

    # 에포크별 검증 정확도와 손실 계산
    val_acc = correct_val / total_val  # 검증 정확도 계산
    val_loss = running_val_loss / len(valid_loader)  # 검증 손실 평균 계산

    # 학습 및 검증 결과 출력
    print(f'Train Loss: {train_loss:.4f}, Train Accuracy: {train_acc:.4f}, '
          f'Validation Loss: {val_loss:.4f}, Validation Accuracy: {val_acc:.4f}')

     # 최상의 검증 정확도를 기록하고 모델 저장
    if val_acc > best_val_acc:
        best_val_acc = val_acc
        torch.save(model.state_dict(), 'best_model_before.pth')
        no_improve = 0
    else:
        no_improve += 1
        if no_improve >= patience:  # 설정한 얼리 스타핑 patience에 도달하면 학습을 중단합니다.
            print("Early stopping")
            break

print('Finished Training')

best model load

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

오차 데이터 분석 - mis label 확인

• 높은 confidence로 예측 했으나, class가 다를 시 해당 데이터의 라벨링이 잘못 되었는지 확인이 필요합니다.

all_df = pd.concat([origin_train_df,test_df])

# 잘못 예측된 이미지와 라벨을 저장할 리스트
mismatched_images = []

# Softmax 함수 초기화 (확률 값으로 변환하기 위함)
softmax = nn.Softmax(dim=1)

# 모델을 GPU로 이동
model = model.to('cuda')  # 만약 사용 가능한 GPU가 있다면.

for index,(img_path,true_label) in tqdm(all_df.iterrows()):

    # Load and preprocess the image
    image = Image.open(img_path).convert('RGB')
    input_tensor = transform(image).unsqueeze(0)

    # 입력 텐서를 GPU로 이동
    input_tensor = input_tensor.to('cuda')  # 만약 사용 가능한 GPU가 있다면.

    # Get model outputs
    with torch.no_grad():
        logits = model(input_tensor)

    # Softmax를 사용하여 확률로 변환
    probabilities = softmax(logits)

    # 가장 높은 확률을 가진 라벨과 그 확률을 추출
    max_prob, predicted_label = torch.max(probabilities, 1)

     # 예측된 라벨이 실제 라벨과 다르고, 확률이 0.90보다 높은 경우 리스트에 추가
    if predicted_label.cpu().item() != true_label and max_prob.item() > 0.90:
        mismatched_images.append((img_path, true_label))

27237it [04:09, 108.98it/s]

label mistakenness 확인

• 높은 confidence로 예측 했으나, class가 다를 시, 해당 데이터의 라벨링이 잘못 되었는지 확인이 필요합니다.

for path,label in mismatched_images:
    print(path, label)
    img = Image.open(path)
    img.show()

./dataset/digit_data/0/00247_0.jpg 0

./dataset/digit_data/0/00411_4.jpg 0

./dataset/digit_data/0/00548_0.jpg 0

./dataset/digit_data/0/00642_4.jpg 0

./dataset/digit_data/0/00832_4.jpg 0

./dataset/digit_data/0/02819_2.jpg 0

./dataset/digit_data/1/02701_3.jpg 1

./dataset/digit_data/2/00140_4.jpg 2

./dataset/digit_data/2/00251_6.jpg 2

./dataset/digit_data/2/00673_1.jpg 2

./dataset/digit_data/2/00767_5.jpg 2

./dataset/digit_data/2/00978_4.jpg 2

./dataset/digit_data/2/02489_3.jpg 2

./dataset/digit_data/3/02282_0.jpg 3

./dataset/digit_data/4/00626_1.jpg 4

./dataset/digit_data/5/00150_2.jpg 5

./dataset/digit_data/5/00268_0.jpg 5

./dataset/digit_data/5/01557_5.jpg 5

./dataset/digit_data/5/01868_6.jpg 5

./dataset/digit_data/5/02526_5.jpg 5

./dataset/digit_data/5/03525_3.jpg 5



![](https://velog.velcdn.com/images/s_s/post/fb359701-5463-446b-8785-ac44a46ff828/image.png)




./dataset/digit_data/6/00064_5.jpg 6




![](https://velog.velcdn.com/images/s_s/post/477e8aff-4bad-4e9c-bc53-95145359d114/image.png)



./dataset/digit_data/6/00617_6.jpg 6



![](https://velog.velcdn.com/images/s_s/post/e26c4162-37ac-42b4-b2b4-9cf541291377/image.png)




./dataset/digit_data/6/02063_5.jpg 6

./dataset/digit_data/7/01186_6.jpg 7

./dataset/digit_data/8/00164_2.jpg 8



![](https://velog.velcdn.com/images/s_s/post/384cff07-df78-4522-b2ab-56d112da101e/image.png)




./dataset/digit_data/8/00239_5.jpg 8



![](https://velog.velcdn.com/images/s_s/post/d6e1da18-74e4-4630-b6bb-d1c7ab5f53dc/image.png)




./dataset/digit_data/8/00826_6.jpg 8



![](https://velog.velcdn.com/images/s_s/post/0fcc20e8-e569-405c-8779-197e1b962703/image.png)




./dataset/digit_data/8/01567_7.jpg 8



![](https://velog.velcdn.com/images/s_s/post/39662e37-418c-421f-bba4-587e17b43c24/image.png)




./dataset/digit_data/0/00527_0.jpg 0



![](https://velog.velcdn.com/images/s_s/post/c92b17f8-300f-41f0-82e9-4b2985602401/image.png)




./dataset/digit_data/0/00744_4.jpg 0

./dataset/digit_data/1/01141_6.jpg 1

./dataset/digit_data/1/02206_6.jpg 1

./dataset/digit_data/2/00025_3.jpg 2

./dataset/digit_data/3/02534_5.jpg 3

./dataset/digit_data/5/00170_2.jpg 5



![](https://velog.velcdn.com/images/s_s/post/1912890b-0b36-48c8-87ef-657116523eec/image.png)




./dataset/digit_data/5/03605_4.jpg 5



![](https://velog.velcdn.com/images/s_s/post/c029c709-0d13-43ad-84c1-c35e5312f4fd/image.png)




./dataset/digit_data/6/01340_6.jpg 6



![](https://velog.velcdn.com/images/s_s/post/04260f5b-a805-4756-9a66-a1d478077cc4/image.png)




./dataset/digit_data/7/00895_3.jpg 7



![](https://velog.velcdn.com/images/s_s/post/7625b753-e31f-434b-a9a8-005aea3d720d/image.png)




./dataset/digit_data/8/02076_3.jpg 8



![](https://velog.velcdn.com/images/s_s/post/dee48ea0-5092-4d63-8a82-b9cbca400598/image.png)




./dataset/digit_data/9/01117_4.jpg 9

잘못된 라벨 수정

• 시각화를 해보니 잘못 라벨링이 된 항목들이 몇 개 보입니다.
• confidence가 높은 오답을 시각화 했을 때, 육안으로 구분 가능한 잘못된 라벨들이 포함되어 있음을 알 수 있습니다
• 모델의 성능 향상을 위해 라벨을 수정하여 줍니다 (가능한 만큼)

# label_index : 라벨을 뜻하는 폴더명의 위치 (split 할 경우)
def move_data(filename: str, label: int, label_index=3):
    moved_paths = []
    for path1 in glob(f"{image_path}/*/{filename}"):
        divided = path1.split("/")
        divided[label_index] = str(label)
        path2 = "/".join(divided)
        if path1 != path2:
            shutil.move(path1, path2)
            print(f"{path1} => {path2}")
            moved_paths.append((path1, path2))
    return moved_paths

image_changes = [
    ("00247_0.jpg", 1),
    ("00642_4.jpg", 3),
    ("02819_2.jpg", 7),
    ("02701_3.jpg", 0),
    ("00140_4.jpg", 3),
    ("02489_3.jpg", 0),
    ("02574_7.jpg", 0),
    ("02282_0.jpg", 2),
    ("00626_1.jpg", 1),
    ("01561_0.jpg", 5),
    ("00150_2.jpg", 1),
    ("00268_0.jpg", 4),
    ("03525_3.jpg", 0),
    ("00617_6.jpg", 1),
    ("00164_2.jpg", 1),
    ("00527_0.jpg", 1),
    ("00025_3.jpg", 0),
    ("02534_5.jpg", 8),
    ("00895_3.jpg", 0),
    ("02334_0.jpg", 2),
    ("00411_4.jpg", 3),
    ("01186_6.jpg", 2),
]

moved_paths = []

# image_changes 리스트를 기반으로 이미지 데이터 이동
for img_file, new_label in image_changes:
    moved_paths.extend(move_data(img_file, new_label))

./dataset/digit_data/0/00247_0.jpg => ./dataset/digit_data/1/00247_0.jpg
./dataset/digit_data/0/00642_4.jpg => ./dataset/digit_data/3/00642_4.jpg
./dataset/digit_data/0/02819_2.jpg => ./dataset/digit_data/7/02819_2.jpg
./dataset/digit_data/1/02701_3.jpg => ./dataset/digit_data/0/02701_3.jpg
./dataset/digit_data/2/00140_4.jpg => ./dataset/digit_data/3/00140_4.jpg
./dataset/digit_data/2/02489_3.jpg => ./dataset/digit_data/0/02489_3.jpg
./dataset/digit_data/2/02574_7.jpg => ./dataset/digit_data/0/02574_7.jpg
./dataset/digit_data/3/02282_0.jpg => ./dataset/digit_data/2/02282_0.jpg
./dataset/digit_data/4/00626_1.jpg => ./dataset/digit_data/1/00626_1.jpg
./dataset/digit_data/4/01561_0.jpg => ./dataset/digit_data/5/01561_0.jpg
./dataset/digit_data/5/00150_2.jpg => ./dataset/digit_data/1/00150_2.jpg
./dataset/digit_data/5/00268_0.jpg => ./dataset/digit_data/4/00268_0.jpg
./dataset/digit_data/5/03525_3.jpg => ./dataset/digit_data/0/03525_3.jpg
./dataset/digit_data/6/00617_6.jpg => ./dataset/digit_data/1/00617_6.jpg
./dataset/digit_data/8/00164_2.jpg => ./dataset/digit_data/1/00164_2.jpg
./dataset/digit_data/0/00527_0.jpg => ./dataset/digit_data/1/00527_0.jpg
./dataset/digit_data/2/00025_3.jpg => ./dataset/digit_data/0/00025_3.jpg
./dataset/digit_data/3/02534_5.jpg => ./dataset/digit_data/8/02534_5.jpg
./dataset/digit_data/7/00895_3.jpg => ./dataset/digit_data/0/00895_3.jpg
./dataset/digit_data/3/02334_0.jpg => ./dataset/digit_data/2/02334_0.jpg
./dataset/digit_data/0/00411_4.jpg => ./dataset/digit_data/3/00411_4.jpg
./dataset/digit_data/7/01186_6.jpg => ./dataset/digit_data/2/01186_6.jpg

changes_dict = {img_name: new_label for img_name, new_label in image_changes}

def update_labels_txt(txt_path, changes_dict):
    # 함수 설명: 주어진 텍스트 파일(txt_path)의 레이블을 changes_dict에 따라 업데이트합니다.
    # txt_path: 레이블 정보가 저장된 텍스트 파일 경로
    # changes_dict: 이미지 이름을 키로 하고, 변경할 레이블을 값으로 가지는 딕셔너리

    try:
        # 텍스트 파일을 읽기 모드로 열기
        with open(txt_path, 'r') as file:
            data = file.readlines()  # 파일의 모든 라인을 읽어와 리스트로 저장
    except FileNotFoundError:
        # 파일이 존재하지 않을 경우 예외 처리
        print(f"{txt_path} not found.")  # 파일이 없음을 알리는 메시지 출력
        return  # 함수 종료

    # 업데이트된 데이터를 저장할 리스트
    updated_data = []

    # 파일의 각 라인을 반복하면서 레이블을 변경합니다.
    for line in data:
        # 라인에서 이미지 이름 추출 ("/"로 나누어 마지막 부분이 이미지 이름)
        img_name = line.strip().split("/")[-1]

        # changes_dict에 이미지 이름이 있는지 확인
        if img_name in changes_dict:
            # 만약 변경해야 하는 이미지 이름이 있다면, 기존 레이블을 새로운 레이블로 업데이트
            print(f"Updating {img_name}: label {line.strip().split('/')[0]} => {changes_dict[img_name]}")
            # 변경된 레이블과 이미지 이름을 새로운 형식으로 저장
            updated_data.append(f"{changes_dict[img_name]}/{img_name}\n")
        else:
            # 변경할 필요가 없는 경우, 원래의 라인을 그대로 저장
            updated_data.append(line)

    # 업데이트된 데이터를 원래 파일에 덮어쓰기
    try:
        with open(txt_path, 'w') as file:
            file.writelines(updated_data)  # 모든 업데이트된 라인을 파일에 기록
    except IOError:
        # 파일 쓰기 중 에러가 발생할 경우 예외 처리
        print(f"Error writing to {txt_path}.")  # 쓰기 실패 메시지 출력

# txt 파일 업데이트
train_txt_path = f"{image_path}/train_data.txt"
update_labels_txt(train_txt_path, changes_dict)

Updating 00247_0.jpg: label 0 => 1
Updating 00411_4.jpg: label 0 => 3
Updating 00642_4.jpg: label 0 => 3
Updating 02819_2.jpg: label 0 => 7
Updating 02701_3.jpg: label 1 => 0
Updating 00140_4.jpg: label 2 => 3
Updating 02489_3.jpg: label 2 => 0
Updating 02574_7.jpg: label 2 => 0
Updating 02282_0.jpg: label 3 => 2
Updating 02334_0.jpg: label 3 => 2
Updating 00626_1.jpg: label 4 => 1
Updating 01561_0.jpg: label 4 => 5
Updating 00150_2.jpg: label 5 => 1
Updating 00268_0.jpg: label 5 => 4
Updating 03525_3.jpg: label 5 => 0
Updating 00617_6.jpg: label 6 => 1
Updating 01186_6.jpg: label 7 => 2
Updating 00164_2.jpg: label 8 => 1

valid_txt_path = f"{image_path}/valid_data.txt"
update_labels_txt(valid_txt_path, changes_dict)

Updating 00527_0.jpg: label 0 => 1
Updating 00025_3.jpg: label 2 => 0
Updating 02534_5.jpg: label 3 => 8
Updating 00895_3.jpg: label 7 => 0

수정된 데이터셋 로드

# 학습 데이터셋
origin_train_df = pd.read_csv(f"{image_path}/train_data.txt", names=["path"])
origin_train_df["label"] = origin_train_df["path"].str[0].astype(int)
origin_train_df["path"] = image_path + "/" + origin_train_df["path"]
origin_train_df

# 테스트 데이터셋 (valid_data.txt지만 미리 나눠진 test set으로 사용하도록 하겠음)
test_df = pd.read_csv(f"{image_path}/valid_data.txt", names=["path"])
test_df["label"] = test_df["path"].str[0].astype(int)
test_df["path"] = image_path + "/" + test_df["path"]
test_df

Train/Valid/Test 데이터셋 분리

# train 데이터셋을 8:2로 나눠서 valid를 하도록 하겠습니다
train_df, valid_df = train_test_split(
    origin_train_df,
    test_size=0.2,
    random_state=0,
    shuffle=True,
    stratify=origin_train_df["label"],
)

Data Augmentation & DataLoader 생성

이미지 데이터의 수가 불균형하므로 학습 시 모델의 성능 저하가 발생하고 예측의 편향이 발생할 수 있고, Overfitting이 발생할 수 있습니다.

데이터의 개수가 적은 4, 5, 7, 8, 9 이미지를 현재 이미지 개수의 평균만큼만 데이터 증강(Data Augmentation)을 수행합니다.

# 사용자 정의 데이터셋 클래스 생성 (CustomDataset)
class CustomDataset(Dataset):
    def __init__(self, dataframe, transform=None):
        # 데이터셋 초기화
        # dataframe: 이미지 경로와 레이블이 포함된 데이터프레임
        # transform: 이미지에 적용할 전처리(transform) 함수
        self.dataframe = dataframe
        self.transform = transform

    def __len__(self):
        # 데이터셋의 총 샘플 수 반환
        return len(self.dataframe)

    def __getitem__(self, idx):
        # 주어진 인덱스(idx)에 해당하는 샘플을 반환
        # 이미지 경로를 데이터프레임에서 가져옴
        img_name = self.dataframe.iloc[idx, 0]
        # 이미지 파일을 열고 RGB 모드로 변환
        img = Image.open(img_name).convert('RGB')
        # 레이블 정보를 정수형으로 가져옴
        label = int(self.dataframe.iloc[idx, 1])

        # transform이 지정되어 있다면 이미지에 전처리를 적용
        if self.transform:
            img = self.transform(img)

        # 이미지와 레이블을 반환
        return img, label

# 특정 레이블을 가진 데이터만 포함하는 AugmentedDataset 클래스 생성
class AugmentedDataset(Dataset):
    def __init__(self, dataframe, transform=None):
        # 데이터프레임에서 특정 레이블(4, 5, 7, 8, 9)만 필터링하여 데이터셋 생성
        self.dataframe = dataframe[dataframe['label'].isin([4, 5, 7, 8, 9])]
        self.transform = transform

    def __len__(self):
        # 데이터셋의 총 샘플 수 반환
        return len(self.dataframe)

    def __getitem__(self, idx):
        # 주어진 인덱스(idx)에 해당하는 샘플을 반환
        # 이미지 경로를 데이터프레임에서 가져옴
        img_name = self.dataframe.iloc[idx, 0]
        # 이미지 파일을 열고 RGB 모드로 변환
        img = Image.open(img_name).convert('RGB')
        # 레이블 정보를 정수형으로 가져옴
        label = int(self.dataframe.iloc[idx, 1])

        # transform이 지정되어 있다면 이미지에 전처리를 적용
        if self.transform:
            img = self.transform(img)

        # 이미지와 레이블을 반환
        return img, label

# 데이터 전처리(transform) 정의
transform = transforms.Compose([
    transforms.Resize((224, 224)),  # 이미지를 224x224로 리사이즈
    transforms.ToTensor(),  # 이미지를 텐서로 변환 (0-255 값을 0-1 범위로 변환)
    transforms.Normalize(mean=normalized_channel_means, std=normalized_channel_stds),  # 채널별 평균과 표준편차로 정규화
])

# 데이터 증강을 위한 transform 정의
augment_transform = transforms.Compose([
    transforms.Resize((224, 224)),  # 이미지를 224x224로 리사이즈
    transforms.RandomRotation(10),  # 이미지를 -10도에서 10도 사이로 랜덤 회전
    transforms.ToTensor(),  # 이미지를 텐서로 변환
    transforms.Normalize(mean=normalized_channel_means, std=normalized_channel_stds),  # 채널별 평균과 표준편차로 정규화
])

# 배치 사이즈 설정
batch_size = 256  # 한 번에 처리할 데이터의 개수

# CustomDataset 인스턴스 생성 (기본 학습 데이터셋)
train_dataset = CustomDataset(train_df, transform=transform)
# AugmentedDataset 인스턴스 생성 (증강된 학습 데이터셋)
augmented_dataset = AugmentedDataset(train_df, transform=augment_transform)

# 기본 학습 데이터셋과 증강된 데이터셋을 결합하여 하나의 데이터셋으로 생성
combined_train_dataset = ConcatDataset([train_dataset, augmented_dataset])

# DataLoader 생성 (학습, 검증, 테스트 데이터셋)
train_loader = DataLoader(combined_train_dataset, batch_size=batch_size, shuffle=True, num_workers=4)  # 학습 데이터 로더 (데이터 섞기 활성화)
valid_loader = DataLoader(CustomDataset(valid_df, transform=transform), batch_size=batch_size, shuffle=True, num_workers=4)  # 검증 데이터 로더
test_loader = DataLoader(CustomDataset(test_df, transform=transform), batch_size=batch_size, shuffle=False, num_workers=4)  # 테스트 데이터 로더 (데이터 섞기 비활성화)

## ResNet 모델 학습

# 사전 학습된 ResNet18 모델 불러오기
model = models.resnet18(pretrained=True)

# 모델의 마지막 완전 연결 계층(fc)을 사용자 정의 계층으로 대체
# 이 계층은 in_features에서 10개의 출력으로 매핑합니다 (10개 클래스 분류를 위함)
model.fc = nn.Sequential(
    nn.Linear(model.fc.in_features, 10),
)

class_counts = train_df['label'].value_counts().sort_index().values

augmented_labels = [4, 5, 7, 8, 9]
class_counts[augmented_labels] = class_counts[augmented_labels] * 2

weights = [1 / class_count for class_count in class_counts]
class_weights = torch.FloatTensor(weights).cuda()

criterion = nn.CrossEntropyLoss(weight=class_weights)
optimizer = torch.optim.Adam(model.parameters(), lr=1e-5, weight_decay=1e-5)

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = model.to(device)

/usr/local/lib/python3.7/dist-packages/torchvision/models/_utils.py:209: UserWarning: The parameter 'pretrained' is deprecated since 0.13 and may be removed in the future, please use 'weights' instead.
  f"The parameter '{pretrained_param}' is deprecated since 0.13 and may be removed in the future, "
/usr/local/lib/python3.7/dist-packages/torchvision/models/_utils.py:223: UserWarning: Arguments other than a weight enum or `None` for 'weights' are deprecated since 0.13 and may be removed in the future. The current behavior is equivalent to passing `weights=ResNet18_Weights.IMAGENET1K_V1`. You can also use `weights=ResNet18_Weights.DEFAULT` to get the most up-to-date weights.
  warnings.warn(msg)

# 전체 훈련 횟수 설정
num_epochs = 50
# 최고 검증 정확도 초기화
best_val_acc = 0.0
# 얼리 스타핑을 위한 조건 설정 (성능 향상이 없을 때 몇 에포크까지 기다릴지)
patience = 5
# 연속적으로 성능 향상이 없는 에포크 수를 추적
no_improve = 0

# 훈련 및 검증 손실을 추적하기 위한 리스트
train_losses = []
valid_losses = []

# 정해진 훈련 횟수만큼 반복
for epoch in range(num_epochs):

    model.train() # 모델을 훈련 모드로 설정
    running_loss = 0.0
    correct_train = 0
    total_train = 0

     # 훈련 데이터 로더를 통해 배치를 반복
    for inputs, labels in tqdm(train_loader, desc=f"Epoch {epoch+1}/{num_epochs}", dynamic_ncols=True):
        inputs, labels = inputs.to(device), labels.to(device)

        optimizer.zero_grad() # 이전 반복에서 계산된 그래디언트를 초기화
        outputs = model(inputs) # 모델에 입력을 전달하여 출력을 계산
        loss = criterion(outputs, labels) # 손실 함수를 사용하여 손실 계산
        loss.backward() # 손실에 대한 그래디언트를 계산
        optimizer.step() # 옵티마이저를 사용하여 모델의 가중치를 업데이트

        running_loss += loss.item()  # 총 손실을 누적

        _, predicted = torch.max(outputs.data, 1) # 예측 결과 계산
        total_train += labels.size(0) # 전체 레이블 수 업데이트
        correct_train += (predicted == labels).sum().item() # 정확한 예측 수 업데이트

    # 에포크별 훈련 정확도 및 손실 계산
    train_acc = correct_train / total_train
    train_loss = running_loss / len(train_loader)

    # Validate
    model.eval()
    running_val_loss = 0.0
    correct_val = 0
    total_val = 0
    with torch.no_grad():
        for inputs, labels in valid_loader:
            inputs, labels = inputs.to(device), labels.to(device)
            outputs = model(inputs)
            loss = criterion(outputs, labels)

            running_val_loss += loss.item()

            _, predicted = torch.max(outputs.data, 1)
            total_val += labels.size(0)
            correct_val += (predicted == labels).sum().item()

    val_acc = correct_val / total_val
    val_loss = running_val_loss / len(valid_loader)

    # 손실 기록
    train_losses.append(train_loss)
    valid_losses.append(val_loss)

    print(f'Train Loss: {train_loss:.4f}, Train Accuracy: {train_acc:.4f}, '
          f'Validation Loss: {val_loss:.4f}, Validation Accuracy: {val_acc:.4f}')

    # 최고 검증 정확도를 갱신하고 모델 저장
    if val_acc > best_val_acc:
        best_val_acc = val_acc
        torch.save(model.state_dict(), 'best_model_after.pth')
        no_improve = 0
    else:
        no_improve += 1 # 성능 향상이 없으면 no_improve 카운터 증가
        if no_improve >= patience:  # 설정한 얼리 스타핑 patience에 도달하면 학습을 중단합니다.
            print("Early stopping")
            break

print('Finished Training')

Epoch 1/50: 100%|██████████| 21/21 [00:32<00:00,  1.53s/it]


Train Loss: 2.1961, Train Accuracy: 0.1828, Validation Loss: 2.0223, Validation Accuracy: 0.2999


Epoch 2/50: 100%|██████████| 21/21 [00:32<00:00,  1.54s/it]


Train Loss: 1.7645, Train Accuracy: 0.4246, Validation Loss: 1.6268, Validation Accuracy: 0.5202


Epoch 3/50: 100%|██████████| 21/21 [00:32<00:00,  1.53s/it]


Train Loss: 1.4034, Train Accuracy: 0.6086, Validation Loss: 1.3011, Validation Accuracy: 0.6583


Epoch 4/50: 100%|██████████| 21/21 [00:32<00:00,  1.54s/it]


Train Loss: 1.1005, Train Accuracy: 0.7387, Validation Loss: 1.0421, Validation Accuracy: 0.7632


Epoch 5/50: 100%|██████████| 21/21 [00:32<00:00,  1.53s/it]


Train Loss: 0.8541, Train Accuracy: 0.8256, Validation Loss: 0.8000, Validation Accuracy: 0.8398


Epoch 6/50: 100%|██████████| 21/21 [00:32<00:00,  1.53s/it]


Train Loss: 0.6497, Train Accuracy: 0.8779, Validation Loss: 0.6262, Validation Accuracy: 0.8850


Epoch 7/50: 100%|██████████| 21/21 [00:32<00:00,  1.53s/it]


Train Loss: 0.4918, Train Accuracy: 0.9118, Validation Loss: 0.4855, Validation Accuracy: 0.9119


Epoch 8/50: 100%|██████████| 21/21 [00:32<00:00,  1.54s/it]


Train Loss: 0.3787, Train Accuracy: 0.9327, Validation Loss: 0.3751, Validation Accuracy: 0.9302


Epoch 9/50: 100%|██████████| 21/21 [00:32<00:00,  1.54s/it]


Train Loss: 0.2984, Train Accuracy: 0.9465, Validation Loss: 0.3162, Validation Accuracy: 0.9436


Epoch 10/50: 100%|██████████| 21/21 [00:32<00:00,  1.54s/it]


Train Loss: 0.2402, Train Accuracy: 0.9577, Validation Loss: 0.2613, Validation Accuracy: 0.9525


Epoch 11/50: 100%|██████████| 21/21 [00:32<00:00,  1.54s/it]


Train Loss: 0.1980, Train Accuracy: 0.9661, Validation Loss: 0.2280, Validation Accuracy: 0.9580


Epoch 12/50: 100%|██████████| 21/21 [00:32<00:00,  1.53s/it]


Train Loss: 0.1658, Train Accuracy: 0.9712, Validation Loss: 0.1984, Validation Accuracy: 0.9598


Epoch 13/50: 100%|██████████| 21/21 [00:32<00:00,  1.53s/it]


Train Loss: 0.1412, Train Accuracy: 0.9759, Validation Loss: 0.1740, Validation Accuracy: 0.9633


Epoch 14/50: 100%|██████████| 21/21 [00:32<00:00,  1.53s/it]


Train Loss: 0.1230, Train Accuracy: 0.9797, Validation Loss: 0.1623, Validation Accuracy: 0.9672


Epoch 15/50: 100%|██████████| 21/21 [00:32<00:00,  1.53s/it]


Train Loss: 0.1075, Train Accuracy: 0.9820, Validation Loss: 0.1424, Validation Accuracy: 0.9683


Epoch 16/50: 100%|██████████| 21/21 [00:32<00:00,  1.53s/it]


Train Loss: 0.0960, Train Accuracy: 0.9841, Validation Loss: 0.1376, Validation Accuracy: 0.9709


Epoch 17/50: 100%|██████████| 21/21 [00:32<00:00,  1.53s/it]


Train Loss: 0.0848, Train Accuracy: 0.9865, Validation Loss: 0.1215, Validation Accuracy: 0.9722


Epoch 18/50: 100%|██████████| 21/21 [00:32<00:00,  1.54s/it]


Train Loss: 0.0761, Train Accuracy: 0.9878, Validation Loss: 0.1209, Validation Accuracy: 0.9736


Epoch 19/50: 100%|██████████| 21/21 [00:32<00:00,  1.53s/it]


Train Loss: 0.0682, Train Accuracy: 0.9892, Validation Loss: 0.1140, Validation Accuracy: 0.9757


Epoch 20/50: 100%|██████████| 21/21 [00:32<00:00,  1.53s/it]


Train Loss: 0.0616, Train Accuracy: 0.9911, Validation Loss: 0.1121, Validation Accuracy: 0.9754


Epoch 21/50: 100%|██████████| 21/21 [00:32<00:00,  1.53s/it]


Train Loss: 0.0563, Train Accuracy: 0.9921, Validation Loss: 0.1030, Validation Accuracy: 0.9768


Epoch 22/50: 100%|██████████| 21/21 [00:32<00:00,  1.53s/it]


Train Loss: 0.0505, Train Accuracy: 0.9922, Validation Loss: 0.0935, Validation Accuracy: 0.9771


Epoch 23/50: 100%|██████████| 21/21 [00:32<00:00,  1.53s/it]


Train Loss: 0.0466, Train Accuracy: 0.9935, Validation Loss: 0.0960, Validation Accuracy: 0.9782


Epoch 24/50: 100%|██████████| 21/21 [00:32<00:00,  1.54s/it]


Train Loss: 0.0426, Train Accuracy: 0.9942, Validation Loss: 0.0910, Validation Accuracy: 0.9798


Epoch 25/50: 100%|██████████| 21/21 [00:32<00:00,  1.53s/it]


Train Loss: 0.0397, Train Accuracy: 0.9943, Validation Loss: 0.0840, Validation Accuracy: 0.9803


Epoch 26/50: 100%|██████████| 21/21 [00:32<00:00,  1.54s/it]


Train Loss: 0.0363, Train Accuracy: 0.9952, Validation Loss: 0.0862, Validation Accuracy: 0.9800


Epoch 27/50: 100%|██████████| 21/21 [00:32<00:00,  1.52s/it]


Train Loss: 0.0340, Train Accuracy: 0.9959, Validation Loss: 0.0840, Validation Accuracy: 0.9812


Epoch 28/50: 100%|██████████| 21/21 [00:32<00:00,  1.53s/it]


Train Loss: 0.0313, Train Accuracy: 0.9962, Validation Loss: 0.0853, Validation Accuracy: 0.9805


Epoch 29/50: 100%|██████████| 21/21 [00:32<00:00,  1.53s/it]


Train Loss: 0.0286, Train Accuracy: 0.9970, Validation Loss: 0.0859, Validation Accuracy: 0.9821


Epoch 30/50: 100%|██████████| 21/21 [00:32<00:00,  1.53s/it]


Train Loss: 0.0263, Train Accuracy: 0.9969, Validation Loss: 0.0850, Validation Accuracy: 0.9807


Epoch 31/50: 100%|██████████| 21/21 [00:32<00:00,  1.53s/it]


Train Loss: 0.0251, Train Accuracy: 0.9973, Validation Loss: 0.0739, Validation Accuracy: 0.9823


Epoch 32/50: 100%|██████████| 21/21 [00:32<00:00,  1.54s/it]


Train Loss: 0.0228, Train Accuracy: 0.9978, Validation Loss: 0.0747, Validation Accuracy: 0.9819


Epoch 33/50: 100%|██████████| 21/21 [00:32<00:00,  1.54s/it]


Train Loss: 0.0218, Train Accuracy: 0.9982, Validation Loss: 0.0733, Validation Accuracy: 0.9830


Epoch 34/50: 100%|██████████| 21/21 [00:32<00:00,  1.53s/it]


Train Loss: 0.0198, Train Accuracy: 0.9983, Validation Loss: 0.0804, Validation Accuracy: 0.9830


Epoch 35/50: 100%|██████████| 21/21 [00:32<00:00,  1.53s/it]


Train Loss: 0.0190, Train Accuracy: 0.9983, Validation Loss: 0.0749, Validation Accuracy: 0.9832


Epoch 36/50: 100%|██████████| 21/21 [00:32<00:00,  1.53s/it]


Train Loss: 0.0179, Train Accuracy: 0.9985, Validation Loss: 0.0749, Validation Accuracy: 0.9835


Epoch 37/50: 100%|██████████| 21/21 [00:32<00:00,  1.53s/it]


Train Loss: 0.0166, Train Accuracy: 0.9989, Validation Loss: 0.0773, Validation Accuracy: 0.9835


Epoch 38/50: 100%|██████████| 21/21 [00:32<00:00,  1.54s/it]


Train Loss: 0.0157, Train Accuracy: 0.9986, Validation Loss: 0.0699, Validation Accuracy: 0.9832


Epoch 39/50: 100%|██████████| 21/21 [00:32<00:00,  1.54s/it]


Train Loss: 0.0149, Train Accuracy: 0.9990, Validation Loss: 0.0653, Validation Accuracy: 0.9837


Epoch 40/50: 100%|██████████| 21/21 [00:32<00:00,  1.53s/it]


Train Loss: 0.0141, Train Accuracy: 0.9990, Validation Loss: 0.0716, Validation Accuracy: 0.9837


Epoch 41/50: 100%|██████████| 21/21 [00:32<00:00,  1.54s/it]


Train Loss: 0.0132, Train Accuracy: 0.9992, Validation Loss: 0.0715, Validation Accuracy: 0.9835


Epoch 42/50: 100%|██████████| 21/21 [00:32<00:00,  1.53s/it]


Train Loss: 0.0127, Train Accuracy: 0.9992, Validation Loss: 0.0703, Validation Accuracy: 0.9837


Epoch 43/50: 100%|██████████| 21/21 [00:32<00:00,  1.53s/it]


Train Loss: 0.0118, Train Accuracy: 0.9992, Validation Loss: 0.0736, Validation Accuracy: 0.9837


Epoch 44/50: 100%|██████████| 21/21 [00:32<00:00,  1.53s/it]


Train Loss: 0.0110, Train Accuracy: 0.9993, Validation Loss: 0.0761, Validation Accuracy: 0.9837
Early stopping
Finished Training

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

<All keys matched successfully>

# Validate
all_labels = []
all_predictions = []
with torch.no_grad():
    for inputs, labels in valid_loader:
        inputs, labels = inputs.to(device), labels.to(device)
        outputs = model(inputs)
        _, predicted = torch.max(outputs.data, 1)

        all_labels.append(labels.cpu().numpy())
        all_predictions.append(predicted.cpu().numpy())

all_labels = np.concatenate(all_labels)
all_predictions = np.concatenate(all_predictions)

conf_mat = confusion_matrix(all_labels, all_predictions)
conf_mat_normalized = conf_mat.astype('float') / conf_mat.sum(axis=1)[:, np.newaxis]

혼동행렬로 시각화

• 이 혼동행렬 히트맵은 모델이 0부터 9까지의 숫자를 얼마나 잘 분류하는지를 보여줍니다.
• 각 행은 실제 라벨을, 각 열은 모델이 예측한 라벨을 나타냅니다.
• 대각선 상의 값이 높으면 높을수록 모델의 예측 정확도가 높음을 의미합니다.
• 이 히트맵에서는 모든 클래스(0~9)가 95% 이상의 높은 정확도로 잘 예측되었음을 확인할 수 있습니다.
• 이는 모델이 각 클래스를 정확하게 분류하는 데 효과적임을 나타냅니다.

plt.figure(figsize=(8, 8))
sns.heatmap(conf_mat_normalized, annot=True, cmap='Blues')
plt.xlabel('Predicted')
plt.ylabel('True')
plt.title('Normalized Confusion Matrix')
plt.show()

Loss 시각화

• 이 그래프는 학습 과정에서의 train loss와 validation loss의 변화를 보여줍니다.
• x축은 에포크를, y축은 손실 값을 나타냅니다.
• train loss는 모델이 훈련 데이터에 얼마나 잘 맞는지를 나타내며, validation loss는 모델이 보지 못한 데이터에 대한 성능을 나타냅니다.
• 두 손실 모두 시간이 지남에 따라 안정적으로 감소하는 추세를 보이면, 이는 모델이 제대로 학습되고 있음을 의미합니다.
• 급격한 변동이나 높은 손실 값이 지속되지 않는 것은 모델이 과적합 없이 일반화 능력을 갖추고 있음을 시사합니다.

actual_epochs = len(train_losses)

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

# Train Loss 그래프
axes[0].plot(range(1, actual_epochs + 1), train_losses, label='Train', color='blue')
axes[0].set_xlabel('Epoch')
axes[0].set_ylabel('Loss')
axes[0].set_title('Training Loss')
axes[0].legend()

# Validation Loss 그래프
axes[1].plot(range(1, actual_epochs + 1), valid_losses, label='Validation', color='orange')
axes[1].set_xlabel('Epoch')
axes[1].set_ylabel('Loss')
axes[1].set_title('Validation Loss')
axes[1].legend()

# 그래프 출력
plt.tight_layout()
plt.show()

1. 전이학습(Transfer Learning)이란?

   • 전이학습은 기존에 학습된 모델의 가중치를 새로운 문제에 활용하는 방법입니다.

   • 대규모 데이터셋에서 사전 학습된 모델을 통해 기본적인 특성(feature)을 이해하게 하고, 이를 새로운 데이터셋에 적용하여 모델 학습 시간을 줄이고 성능을 향상시킬 수 있습니다.

   • 전이학습은 특히 이미지 분류와 같이 대량의 데이터가 필요하고 복잡한 모델 구조가 요구되는 작업에서 유용하게 사용됩니다.

   • 전이학습은 주로 두 단계로 이루어집니다:

     1. 사전학습(Pre-training): 대규모 데이터셋으로 모델을 학습시켜 기본적인 특징 추출 능력을 갖춥니다
     2. 미세조정(Fine-tuning): 사전학습된 모델을 특정 작업에 맞게 조정합니다. 이 과정에서는 적은 양의 데이터로도 효과적인 학습이 가능합니다.
     

2. 전이학습의 주요 개념

   • 기존 모델 활용: ImageNet과 같은 대규모 데이터셋으로 학습된 모델은 다양한 시각적 특성을 이미 학습하였으므로, 이를 재사용하여 새로운 데이터셋에 쉽게 적용할 수 있습니다.
   • 가중치 고정(freeze): 사전 학습된 모델의 가중치를 고정하고 새로운 데이터셋에서 상위 특성(고수준 특징)을 학습합니다. 이렇게 하면 기존의 특성 추출 기능을 보존하면서 학습의 범위를 좁힐 수 있습니다.
   • 미세 조정(Fine-tuning): 모델의 일부 가중치를 학습 가능하게 두고 새로운 데이터셋에 맞춰 추가 학습을 진행합니다. 이를 통해 기존 모델이 학습하지 못한 고유한 데이터셋의 특성을 잘 반영할 수 있습니다.

3. 전이학습의 장점

   • 효율성: 적은 양의 데이터로도 높은 성능을 얻을 수 있습니다.
   • 시간 단축: 사전 학습된 모델의 특성을 재사용함으로써 모델 훈련에 필요한 시간을 줄입니다.
   • 높은 성능: 복잡한 데이터셋에서도 더 나은 결과를 기대할 수 있습니다.

Task 소개 : OCR

Optical Character Recognition(OCR)은 기술이 발전하며 전통적인 문서를 디지털 형태로 변환하는 데 사용되는 중요한 기술로 자리 잡았습니다. OCR은 사람이 쓰거나 기계로 인쇄한 문자들을 스캔하고, 이를 텍스트 데이터로 변환합니다. 이를 통해 수많은 문서들이 검색 가능하고 편집 가능한 형태로 재사용될 수 있게 됩니다.

이 기술은 글자와 단어를 정확하게 인식하여 디지털 데이터로 변환하는데 중점을 둡니다. 한글, 영어, 숫자 등 다양한 문자를 인식할 수 있으며, 다양한 언어와 폰트에서도 확장하여 적용이 가능합니다.

라이브러리 import

# 데이터 처리 및 분석을 위한 라이브러리
import pandas as pd  # 데이터 처리 및 분석을 위한 라이브러리
from sklearn.model_selection import train_test_split  # 데이터 세트를 훈련 및 테스트 세트로 분할하는 데 사용

# 파일 및 경로 처리를 위한 라이브러리
import os  # 운영 체제와 상호작용, 파일 및 디렉토리 경로 처리에 사용
import glob  # 파일 시스템 내의 파일 경로명을 찾는 데 사용

# 이미지 처리를 위한 라이브러리
from PIL import Image  # 이미지 파일을 열고 조작하는 데 사용

# 데이터 시각화를 위한 라이브러리
import matplotlib.pyplot as plt  # 데이터 시각화를 위한 플로팅 라이브러리

# 기타 유틸리티
import random  # 난수 생성 및 무작위 선택을 위한 유틸리티 함수 제공
from typing import *  # 타입 힌트 및 제네릭 타입을 위한 라이브러리

Google Colab에서 데이터 관리 및 최적 활용 전략

드라이브 설정

• 코랩에서 데이터에 접근하는 방법에는 크게 두 가지가 있습니다.

  • 1. 구글 드라이브 연동 : 자신의 Google Drive를 코랩에 연결하여 드라이브 안의 데이터에 접근합니다.
  • 2. 코랩의 세션 드라이브 업로드 : 코랩의 임시 저장 공간에 데이터를 업로드하여 사용합니다.

• 각각의 방법은 장단점을 가지고 있습니다.

• 구글 드라이브 연동의 장점은 드라이브에 데이터가 미리 준비되어 있으면 즉시 사용할 수 있다는 것이며, 데이터가 지속적으로 보존됩니다. 단점은 이미지 데이터와 같이 용량이 큰 데이터를 다룰 때, 로딩 속도가 매우 느리다는 단점이 있습니다.

• 코랩의 세션 드라이브에 업로드하는 방법의 장점은 드라이브 연동에 비해 로딩 속도를 매우 빠르게 사용할 수 있다는 것입니다. 하지만 이 방법의 단점은 코랩 런타임이 초기화될 때마다 데이터가 사라지고, 다른 ipynb에서 접근이 안된다는 단점이 존재합니다.

• 따라서 이미지 데이터와 같이 대용량의 학습 데이터는 학습 직전에 임시 경로에 업로드하여 사용하고, 그 외 필요한 파일들은 구글 드라이브에서 직접 불러오는 것이 좋습니다. 이렇게 하면 데이터 사용의 효율성과 접근성을 극대화할 수 있습니다.

코랩의 세션 드라이브에 데이터 업로드

import gdown

# Google Drive 파일 ID와 URL 설정
file_id = "1U7vCDZ4X9ElceQvBllL8ccGHXHjc1qTw"
url = f"https://drive.google.com/uc?id={file_id}"

# 다운로드할 파일 이름 설정
output = "OCR_ResNet18_dataset.zip"

# gdown을 사용하여 파일 다운로드
gdown.download(url, output, quiet=False)

print(f"파일 다운로드가 완료되었습니다: {output}")

Downloading...
From (original): https://drive.google.com/uc?id=1U7vCDZ4X9ElceQvBllL8ccGHXHjc1qTw
From (redirected): https://drive.google.com/uc?id=1U7vCDZ4X9ElceQvBllL8ccGHXHjc1qTw&confirm=t&uuid=2e7bc296-418a-47e6-bb69-f5cb9d5d22f5
To: /content/OCR_ResNet18_dataset.zip
100%|██████████| 82.9M/82.9M [00:03<00:00, 22.2MB/s]

파일 다운로드가 완료되었습니다: OCR_ResNet18_dataset.zip

# unzip 명령어를 통해 압축 파일을 해제해 줍니다.
!unzip -qq OCR_ResNet18_dataset.zip

# 코랩 환경에서 오른쪽 폴더 모양의 아이콘을 누르면 세션 드라이브 및 연동된 구글 드라이브를 확인할 수 있습니다.
root_path = os.getcwd() # 현재 경로를 root_path로 설정합니다.
print(root_path)

/content

# 코랩 드라이브에서 대량의 파일을 로드할 경우 매우 시간이 오래 걸립니다.
# 따라서 추후 사용할 이미지는 drive가 아닌 코랩 세션 드라이브의 경로로 설정해주고, 추후 해당 경로에 데이터를 업로드해줍니다.
image_path = os.path.join(root_path,"dataset","digit_data")
asset_path = "./assets"

# 학습 데이터셋
origin_train_df = pd.read_csv(os.path.join(image_path, "train_data.txt"), names=["path"])
origin_train_df["label"] = origin_train_df["path"].str[0].astype(int)
origin_train_df["path"] = origin_train_df["path"].apply(lambda x: os.path.join(image_path,x))
origin_train_df

Train/Valid/Test 데이터셋 분리

kamp데이터는 train/valid 밖에 구분되어 있지 않지만

저희는 보다 명확한 검토를 위해

train => train/valid

valid = > test

로 사용하도록 하겠습니다

# train 데이터셋을 8:2로 나눠서 valid를 하도록 하겠습니다
train_df, valid_df = train_test_split(
    origin_train_df,
    test_size=0.2,
    random_state=0,
    shuffle=True,
    stratify=origin_train_df["label"],
)

EDA

• 제조현장용 OCR(Optical Character Recognition) 학습 AI 데이터셋

• 데이터의 품질은 모델 성능을 결정하는 핵심 요소입니다. 모델의 최적 성능을 위해서는 고품질의 데이터가 필수적입니다.

• 하지만, 대다수의 데이터셋은 예상치 못한 오류나 결점을 포함할 수 있습니다. 그러므로, 단순히 데이터에 의존하기보다는 철저한 검증과정이 필요합니다.탐색적 데이터 분석(EDA)는 이 검증 과정의 핵심입니다. EDA는 데이터의 본질과 구조를 깊게 파악하는 데 중점을 둡니다. 주요 목적은 아래와 같습니다.

  • 데이터 구조 파악
  • 이상치의 탐지
  • 데이터 전처리 방향성 설정
  • 데이터의 시각화

이를 통해 데이터의 품질 향상을 지향합니다.

• 데이터셋 형태 : image파일과 그에 연계된 txt 및 folder name기반 tagging

• 데이터 수집 방법 : 클라우드 기반의 RPMS를 통해, 생산현장에서 업로드된 이미지를 확보. 실제 기업 현장에서 발생하는 계측 이미지를 직접 촬영하여 수집

• 데이터셋 파일 확장자 : 이미지 (jpg), 레이블 (folder name)

• 데이터 개수 : 27,237개(76.1MB)

• 이미지 당 하나의 숫자만 있는 것을 알 수 있습니다

• 7 Segment 이미지는 전반적으로 붉은 빛을 띄고 있습니다 데이터를 normalize할 때 이를 고려하면 더 좋은 성능이 나올 수 있습니다

• 약간 회전되거나 치우쳐져 있어도 맞출 수 있게 rotate, traslate 증강을 적용

• 이미지의 밝기 및 채도가 변화하여도 맞출 수 있게 brightnss, contrast 증강을 적용

image_path

'/content/dataset/digit_data'

# 전체 이미지 리스트 중 임의로 30개 추출하여 시각화합니다.
all_image_list = glob.glob(f'{image_path}/*/*')
image_files = random.sample(all_image_list,30)

# 이미지를 로드하고 저장
images = [Image.open(img) for img in image_files]
labels = list(map(lambda x: x.split('/')[-2], image_files))

# 플롯 설정
fig, axes = plt.subplots(3, 10, figsize=(30, 10))  # 5x4 격자
axes = axes.flatten()

# 각 격자에 이미지 표시
for label,img, ax in zip(labels,images, axes):
    ax.imshow(img)
    ax.axis('off')
    ax.set_title(label, fontsize=8)

plt.show()

• 2와 5는 좌우 반전 시 동일한 형태라는 것을 알 수 있습니다

• 데이터 학습 및 추론 시 좌우 반전을 하게되면 안됩니다

# 전체 이미지 리스트 중 숫자 6과 9를 임의로 20개 추출하여 시각화합니다.
image_6_or_9_list = glob.glob(f'{image_path}/6/*') + glob.glob(f'{image_path}/9/*')
image_files = random.sample(image_6_or_9_list,20)

# 이미지를 로드하고 저장
images = [Image.open(img) for img in image_files]
labels = list(map(lambda x: x.split('/')[-2], image_files))

# 플롯 설정
fig, axes = plt.subplots(2, 5, figsize=(10, 5))  # 2*5 격자
axes = axes.flatten()

# 각 격자에 이미지 표시
for label,img, ax in zip(labels,images, axes):
    ax.imshow(img)
    ax.axis('off')
    ax.set_title(label, fontsize=8)

plt.show()

6과 9는 좌우반전 + 상하반전을 같이해야 같은 모양됩니다 (또는 180도 회전)

그러나 숫자가 거꾸로 출력될 일은 현재 문제에는 없을 것으로 예상되어, 좌우상하 반전은 증강에서 제외하도록 합니다

메타 데이터 분석

# 숫자 폴더 이름 리스트 생성
number_folders = [str(i) for i in range(10)]

# 각 숫자 폴더에서 이미지 개수 카운트
image_counts = []
for folder in number_folders:
    folder_path = os.path.join(image_path, folder)
    count = len([f for f in os.listdir(folder_path) if os.path.isfile(os.path.join(folder_path, f))])
    image_counts.append(count)

# 막대 그래프 생성
plt.bar(number_folders, image_counts, color='blue')
plt.xlabel('Number')
plt.ylabel('Image Count')
plt.title('Image Counts for Each Number')
plt.show()

• 데이터 클래스가 불균형함을 알 수 있습니다

• 모델을 학습 시 이를 고려하여 학습하여야 합니다

• 그렇지 않으면 특정 클래스에 편향된 모델이 개발될 수 있습니다

• 데이터 불균형을 해소하는 방법은 여러가지가 있습니다

언더 샘플링

1. Random Sampling
2. Tomek Links
3. CNN Rule
4. One Sided Selection

언더 샘플링의 장단점

장점

• 다수 범주 데이터의 제거로 계산시간이 감소합니다.

단점

• 데이터 제거로 인한 정보 손실이 발생할 수 있습니다.

오버 샘플링

1. Resampling
2. SMOTE
3. Borderline SMOTE
4. ADASYN
5. GAN

오버 샘플링의 장단점

장점

• 데이터를 증가시키기 때문에 정보 손실이 없습니다.
• 대부분의 경우 언더 샘플링에 비해 높은 분류 정확도를 보입니다.

단점

• 데이터 증가로 인해 계산 시간이 증가할 수 있으며 과적합 가능성이 존재합니다.
• 노이즈 또는 이상치에 민감합니다.

손실 함수

1. Focal Loss
2. Weighted Cross Entropy

# 모든 이미지의 가로 길이를 저장할 리스트
widths = []

# 각 숫자 폴더를 순회하며 이미지의 가로 길이 수집
for folder in number_folders:
    folder_path = os.path.join(image_path, folder)
    # 해당 폴더의 모든 파일에 대해 반복
    for file in os.listdir(folder_path):
        file_path = os.path.join(folder_path, file)
        # 파일이 이미지인 경우만 처리
        if os.path.isfile(file_path) and file.lower().endswith(('.png', '.jpg', '.jpeg')):
            with Image.open(file_path) as img:
                width, height = img.size
                widths.append(width)  # 가로 길이 저장

# 이미지 가로 길이의 분포 시각화
plt.hist(widths, bins=20, color='skyblue', edgecolor='black')
plt.xlabel('Width')
plt.ylabel('Frequency')
plt.title('Distribution of Image Widths')
plt.show()

# 모든 이미지의 세로 길이를 저장할 리스트
heights = []

# 각 숫자 폴더를 순회하며 이미지의 세로 길이 수집
for folder in number_folders:
    folder_path = os.path.join(image_path, folder)
    # 해당 폴더의 모든 파일에 대해 반복
    for file in os.listdir(folder_path):
        file_path = os.path.join(folder_path, file)
        # 파일이 이미지인 경우만 처리
        if os.path.isfile(file_path) and file.lower().endswith(('.png', '.jpg', '.jpeg')):
            with Image.open(file_path) as img:
                width, height = img.size
                heights.append(height)  # 세로 길이 저장

# 이미지 세로 길이의 분포 시각화
plt.hist(heights, bins=20, color='skyblue', edgecolor='black')
plt.xlabel('height')
plt.ylabel('Frequency')
plt.title('Distribution of Image heights')
plt.show()

이미지의 사이즈는 매우 작은 사이즈 ~ 중간 사이즈의 분포임을 알 수 있습니다

모델의 input으로 넣을 이미지 사이즈는 보통의 사이즈로 해도 문제 없을 것으로 보입니다 (224x224)

컨볼루션 신경망(Convolution Neural Networks, CNN)

• 완전 연결 네트워크의 문제점으로부터 시작

  • 매개변수의 폭발적인 증가
  • 공간 추론의 부족: 픽셀 사이의 근접성 개념이 완전 연결 계층(Fully-Connected Layer)에서는 손실됨
  

• 동물의 시각피질의 구조에서 영감을 받아 만들어진 딥러닝 신경망 모델

• 시각 자극이 1차 시각피질을 통해서 처리된 다음, 2차 시각피질을 경유하여, 3차 시각피질 등 여러 영역을 통과하여 계층적인 정보처리

• 정보가 계층적으로 처리되어 가면서 점차 추상적인 특징이 추출되어 시각 인식

• 동물의 계층적 특징 추출과 시각인식 체계를 참조하여 만들어진 모델

  • 전반부 : 컨볼루션 연산을 수행하여 특징 추출
  • 후반부 : 특징을 이용하여 분류

• 영상분류, 문자 인식 등 인식문제에 높은 성능

  

컨볼루션 연산 (Convolution Operation)

• 필터(filter) 연산

  • 입력 데이터에 필터를 통한 어떠한 연산을 진행
  • 필터에 대응하는 원소끼리 곱하고, 그 합을 구함
  • 연산이 완료된 결과 데이터를 특징 맵(feature map)이라 부름

• 필터(filter)

  • 커널(kernel)이라고도 함
  • 이미지 처리에서 사용하는 '이미지 필터'와 비슷한 개념
  • 필터의 사이즈는 거의 항상 홀수
    • SAME 패딩을 사용하여 입력과 출력의 크기를 동일하게 유지하기 쉬움
    • 중심위치가 존재, 즉 구별된 하나의 픽셀(중심 픽셀)이 존재
  • 필터의 학습 파라미터 개수는 입력 데이터의 크기와 상관없이 일정
  • 과적합을 방지할 수 있음
  

• 연산 시각화

  

• 일반적으로, 합성곱 연산을 한 후의 데이터 사이즈

  $\quad (n-f+1) \times (n-f+1)$

  $n$: 입력 데이터의 크기
  $f$: 필터(커널)의 크기

  

• 위 예에서 입력 데이터 크기($n$)는 5, 필터의 크기($k$)는 3이므로 출력 데이터의 크기는 $(5 - 3 + 1) = 3$

필터가 이미지의 특징을 추출하는 과정 (sobel 필터를 예시로)

Sobel 필터란?

• Sobel 필터는 수학적으로 이미지의 밝기 변화(Gradient)를 계산하는 필터임

  • 두 가지 종류가 있음:
  • 수평선 검출 필터: 이미지에서 수평 방향의 변화를 감지.
  • 수직선 검출 필터: 이미지에서 수직 방향의 변화를 감지.

• Sobel 필터를 활용하면 CNN에서 필터가 특징을 추출하는 과정을 직관적으로 이해할 수 있음.

• Sobel 필터는 가장 간단한 에지 검출 필터 중 하나로, 이미지에서 선(에지)을 강조함.

  

  이미지출처: https://www.researchgate.net/figure/Sobel-filter-using-two-33-kernels-Gx-Gy_fig5_375105942

이미지출처: https://learnopencv.com/edge-detection-using-opencv/

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import load_sample_image

from tensorflow.keras.layers import Conv2D

flower = load_sample_image('flower.jpg') / 255
print(flower.dtype)
print(flower.shape)
plt.imshow(flower)
plt.show()

float64
(427, 640, 3)

china = load_sample_image('china.jpg') / 255
print(china.dtype)
print(china.shape)
plt.imshow(china)
plt.show()

float64
(427, 640, 3)

images = np.array([china, flower])
batch_size, height, width, channels = images.shape
print(images.shape)

(2, 427, 640, 3)

# 컨볼루션 연산을 수행할 필터를 직접 생성
filters = np.zeros(shape=(7, 7, channels, 2), dtype=np.float32)
filters[:, 3, :, 0] = 1 # 첫 번째 필터 세로줄 형성
filters[3, :, :, 0] = 1 # 첫 번째 필터 가로줄 형성
filters[3, 3, :, 1] = 1 # 두 번째 필터 중심점 형성

print(filters.shape)

(7, 7, 3, 2)

# 필터가 학습을 통해 자동으로 생성되는 CNN 레이어 생성
convolve = Conv2D(filters=16, kernel_size=7, activation='relu')

패딩(Padding)과 스트라이드(Stride)

• 필터(커널) 사이즈과 함께 입력 이미지와 출력 이미지의 사이즈를 결정하기 위해 사용
• 사용자가 결정할 수 있음

패딩(Padding)

• 입력 데이터의 주변을 특정 값으로 채우는 기법

  • 주로 0으로 많이 채움
  

• 출력 데이터의 크기

  $\quad (n+2p-f+1) \times (n+2p-f+1)$

  • 위 그림에서, 입력 데이터의 크기($n$)는 5, 필터의 크기($f$)는 3, 패딩값($p$)은 1이므로 출력 데이터의 크기는 ($5 + 2\times 1 - 3 + 1) = 5$

• valid

  • 패딩을 주지 않음
  • padding=0은 0으로 채워진 테두리가 아니라 패딩을 주지 않는다는 의미

• same

  • 패딩을 주어 입력 이미지의 크기와 연산 후의 이미지 크기를 같도록 유지
  • 만약, 필터(커널)의 크기가 $k$ 이면, 패딩의 크기는 $p = \frac{k-1}{2}$ (단, stride=1)

스트라이드(Stride)

• 필터를 적용하는 간격을 의미

• 아래 예제 그림은 간격이 2

  

출력 데이터의 크기

$\qquad OH = \frac{H + 2P - FH}{S} + 1 $

$\qquad OW = \frac{W + 2P - FW}{S} + 1 $

• 입력 크기 : $(H, W)$
• 필터 크기 : $(FH, FW)$
• 출력 크기 : $(OH, OW)$
• 패딩, 스트라이드 : $P, S$

• 위 식의 값에서 $\frac{H + 2P - FH}{S}$ 또는 $\frac{W + 2P - FW}{S}$가 정수로 나누어 떨어지는 값이어야 함
• 정수로 나누어 떨어지지 않으면, 패딩, 스트라이드 값을 조정하여 정수로 나누어 떨어지게 해야함

conv = Conv2D(filters=16, kernel_size=3,padding='same',strides=1, activation='relu')

풀링(Pooling)

• 필터(커널) 사이즈 내에서 특정 값을 추출하는 과정

맥스 풀링(Max Pooling)

• 가장 많이 사용되는 방법

• 출력 데이터의 사이즈 계산은 컨볼루션 연산과 동일

  $\quad OH = \frac{H + 2P - FH}{S} + 1 $

  $\quad OW = \frac{W + 2P - FW}{S} + 1 $

• 일반적으로 stride=2, kernel_size=2 를 통해 특징맵의 크기를 절반으로 줄이는 역할

• 모델이 물체의 주요한 특징을 학습할 수 있도록 해주며, 컨볼루션 신경망이 이동 불변성 특성을 가지게 해줌

• 예를 들어, 아래의 그림에서 초록색 사각형 안에 있는 2와 8의 위치를 바꾼다해도 맥스 풀링 연산은 8을 추출

• 모델의 파라미터 개수를 줄여주고, 연산 속도를 빠르게 함

  

from tensorflow.keras.layers import MaxPooling2D

print(flower.shape)
flower = np.expand_dims(flower, axis=0)
print(flower.shape)

output = Conv2D(filters=32, kernel_size=3, strides=1, padding='same',activation='relu')(flower)
print(output.shape) # 아직 학습되지 않아 랜덤한 숫자로 초기화된 필터를 거친 연산 결과

output = MaxPooling2D(pool_size=2)(output)
print(output.shape)

(427, 640, 3)
(1, 427, 640, 3)
(1, 427, 640, 32)
(1, 213, 320, 32)

plt.imshow(output[0,:,:,8],cmap='gray')
plt.show()

평균 풀링(Avg Pooling)

• 필터 내의 있는 픽셀값의 평균을 구하는 과정

• 과거에 많이 사용, 요즘은 잘 사용되지 않음

• 맥스풀링과 마찬가지로 stride=2, kernel_size=2 를 통해 특징 맵의 사이즈를 줄이는 역할

  

from tensorflow.keras.layers import AvgPool2D

print(flower.shape)
output = Conv2D(filters=32, kernel_size=3, strides=1, padding='same',activation='relu')(flower)
output = AvgPool2D(pool_size=2)(output)
print(output.shape)

(1, 427, 640, 3)
(1, 213, 320, 32)

plt.imshow(output[0,:,:,2], cmap='gray')
plt.show()

전역 평균 풀링(Global Avg Pooling)

• 특징 맵 각각의 평균값을 출력하는 것이므로, 특성맵에 있는 대부분의 정보를 잃음
• 출력층에는 유용할 수 있음

from tensorflow.keras.layers import GlobalAvgPool2D

print(flower.shape)
output = Conv2D(filters=32, kernel_size=3, strides=1, padding='same',activation='relu')(flower)
print(output.shape)
output = GlobalAvgPool2D()(output)
print(output.shape)

(1, 427, 640, 3)
(1, 427, 640, 32)
(1, 32)

완전 연결 계층(Fully-Connected Layer)

• 입력으로 받은 텐서를 1차원으로 평면화(flatten) 함
• 밀집 계층(Dense Layer)라고도 함
• 일반적으로 분류기로서 네트워크의 마지막 계층에서 사용

from tensorflow.keras.layers import Dense

output_size = 1000

fc = Dense(units=output_size, activation='softmax')

유효 수용 영역(ERF, Effective Receptive Field)

• 입력 이미지에서 특정 뉴런의 활성화(결과)에 영향을 미치는 이미지의 영역

• 네트워크가 깊어지면 더 많은 필터와 연산이 겹쳐져, 뉴런이 이미지를 "망원경"으로 보는 것처럼 더 넓은 영역을 고려하게 됨

• 따라서 깊은 계층에서는 입력 이미지의 "멀리 떨어진" 부분까지 고려해 특징을 학습할 수 있음

• 유효 수용 영역이 크면 더 복잡하고 넓은 관계(예: 얼굴 전체 구조)를 학습할 수 있으며, 너무 작으면, 작은 패턴(예: 한 부분의 점, 선)만 학습하여 전반적인 구조를 이해하지 못할 수 있음

  

• RF의 중앙에 위치한 픽셀은 주변에 있는 픽셀보다 더 높은 가중치를 가짐

  • 중앙부에 위치한 픽셀은 여러 개의 계층을 전파한 값
  • 중앙부에 있는 픽셀은 주변에 위치한 픽셀보다 더 많은 정보를 가짐

• 가우시안 분포를 따름

  

CNN 모델 학습

MNIST (LeNet)

• Yann LeCun 등의 제안(1998)

• 5 계층 구조: Conv-Pool-Conv- Pool-Conv-FC-FC(SM)

• 입력 : 32x32 필기체 숫자 영상 (MNIST 데이터)

• 풀링 : 가중치x(2x2블록의 합) + 편차항

• 시그모이드 활성화 함수 사용

• 성능: 오차율 0.95%(정확도: 99.05%)

  [LeNet-5 구조]

모듈 임포트

from tensorflow.keras import Model
from tensorflow.keras.layers import Conv2D, MaxPooling2D, Flatten, Dense
from tensorflow.keras.callbacks import EarlyStopping, TensorBoard
from tensorflow.keras.datasets import mnist

import matplotlib.pyplot as plt
import numpy as np

데이터 로드 및 전처리

(x_train, y_train), (x_test, y_test) = mnist.load_data()
x_train, x_test = x_train[:,:,:,np.newaxis] / 255.0, x_test[:,:,:,np.newaxis] / 255.0 # 채널 정보가 누락되어 있으므로 축 추가
print(x_train.shape)
print(y_train.shape)
print(x_test.shape)
print(y_test.shape)

(60000, 28, 28, 1)
(60000,)
(10000, 28, 28, 1)
(10000,)

plt.imshow(x_train[0,:,:,0], cmap='gray')
print(y_train[0])

5

모델 구성 및 컴파일

num_classes = 10
epochs = 30
batch_size = 32

class LeNet5(Model):
    def __init__(self, num_classes=10):
        # 부모 클래스의 기능을 상속받기 위해 부모 클래스의 초기화 메서드(__init__)를 호출
        super(LeNet5, self).__init__()
        # 첫 번째 합성곱 층: 6개의 필터를 사용하고, 각 필터의 크기는 5x5입니다. 
        # 'same' 패딩을 사용하여 입력 이미지와 출력 이미지의 크기를 동일하게 유지합니다.
        # 활성화 함수로는 ReLU를 사용하여 비선형 변환을 제공합니다.
        self.conv1 = Conv2D(filters=6, kernel_size=5, padding='same', activation='relu')

        # 첫 번째 풀링 층: 최대 풀링을 사용하고, 풀링의 크기는 2x2입니다.
        # 이 층은 데이터의 공간 크기를 줄이고, 주요 특징을 유지합니다.
        self.pool1 = MaxPooling2D(pool_size=2)

        # 두 번째 합성곱 층: 16개의 필터를 사용하고, 각 필터의 크기는 5x5입니다.
        # 'same' 패딩을 사용하여 입력 이미지와 출력 이미지의 크기를 동일하게 유지합니다.
        # 활성화 함수로는 ReLU를 사용합니다.
        self.conv2 = Conv2D(filters=16, kernel_size=5, padding='same', activation='relu')

        # 데이터를 일렬로 펼치는 층입니다. 이 층은 합성곱 층과 풀링 층을 거쳐 얻어진
        # 2차원 특징 맵을 1차원 벡터로 변환하여 완전 연결 층에 전달할 수 있도록 합니다.
        self.flatten = Flatten()

        # 첫 번째 완전 연결 층: 120개의 유닛을 가지며, 활성화 함수로 ReLU를 사용합니다.
        # 이 층은 1차원 벡터의 형태로 펼쳐진 데이터를 받아 처리합니다.
        self.fc1 = Dense(units=120, activation='relu')

        # 두 번째 완전 연결 층: 84개의 유닛을 가지며, 활성화 함수로 ReLU를 사용합니다.
        self.fc2 = Dense(units=84, activation='relu')

        # 출력 층: num_classes 개수의 유닛을 가지며, 각 클래스에 대한 확률을 출력하기 위해
        # 활성화 함수로 softmax를 사용합니다.
        self.fc3 = Dense(units=num_classes, activation='softmax')

    def call(self, input_data):
        # 각 층을 차례대로 호출하여 입력 데이터를 처리합니다.
        x = self.conv1(input_data)  # 첫 번째 합성곱 층을 통과
        x = self.pool1(x)           # 첫 번째 풀링 층을 통과
        x = self.conv2(x)           # 두 번째 합성곱 층을 통과
        x = self.pool1(x)           # 두 번째 풀링 층을 통과 (동일한 풀링 층 재사용)
        x = self.flatten(x)         # 플래튼 층을 통과
        x = self.fc1(x)             # 첫 번째 완전 연결 층을 통과
        x = self.fc2(x)             # 두 번째 완전 연결 층을 통과
        x = self.fc3(x)             # 출력 층을 통과
        return x

model = LeNet5(num_classes=10)

model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])

callbacks = [EarlyStopping(patience=3, monitor='val_loss'), TensorBoard(log_dir='./logs', histogram_freq=1)] # histogram_freq=1 : epoch마다 히스토그램 기록

모델 학습 및 평가

model.fit(x_train, y_train,
          batch_size=batch_size,
          epochs=epochs,
          validation_split=0.2,
          callbacks=callbacks)

Epoch 1/30
1500/1500 ━━━━━━━━━━━━━━━━━━━━ 52s 33ms/step - accuracy: 0.8790 - loss: 0.4138 - val_accuracy: 0.9700 - val_loss: 0.0958
Epoch 2/30
1500/1500 ━━━━━━━━━━━━━━━━━━━━ 79s 32ms/step - accuracy: 0.9761 - loss: 0.0724 - val_accuracy: 0.9787 - val_loss: 0.0724
Epoch 3/30
1500/1500 ━━━━━━━━━━━━━━━━━━━━ 79s 29ms/step - accuracy: 0.9857 - loss: 0.0485 - val_accuracy: 0.9855 - val_loss: 0.0482
Epoch 4/30
1500/1500 ━━━━━━━━━━━━━━━━━━━━ 84s 31ms/step - accuracy: 0.9892 - loss: 0.0336 - val_accuracy: 0.9880 - val_loss: 0.0427
Epoch 5/30
1500/1500 ━━━━━━━━━━━━━━━━━━━━ 80s 29ms/step - accuracy: 0.9919 - loss: 0.0254 - val_accuracy: 0.9852 - val_loss: 0.0508
Epoch 6/30
1500/1500 ━━━━━━━━━━━━━━━━━━━━ 82s 30ms/step - accuracy: 0.9939 - loss: 0.0202 - val_accuracy: 0.9874 - val_loss: 0.0451
Epoch 7/30
1500/1500 ━━━━━━━━━━━━━━━━━━━━ 83s 31ms/step - accuracy: 0.9940 - loss: 0.0183 - val_accuracy: 0.9864 - val_loss: 0.0504





<keras.src.callbacks.history.History at 0x7b6eb6a15600>

%load_ext tensorboard

The tensorboard extension is already loaded. To reload it, use:
  %reload_ext tensorboard

%tensorboard --logdir logs

<IPython.core.display.Javascript object>

Fashion MNIST

모듈 임포트

import datetime
import numpy as np
import tensorflow as tf
import matplotlib.pyplot as plt

from tensorflow.keras import Model
from tensorflow.keras.models import Sequential
from tensorflow.keras.utils import to_categorical
from tensorflow.keras.datasets.fashion_mnist import load_data
from tensorflow.keras.preprocessing.image import ImageDataGenerator
from tensorflow.keras.layers import Conv2D, MaxPooling2D, Flatten, Dense, Dropout, Input
from tensorflow.keras.callbacks import EarlyStopping, TensorBoard

데이터 로드 및 전처리

(x_train, y_train), (x_test, y_test) = load_data()
x_train, x_test = x_train[:,:,:,np.newaxis] / 255.0, x_test[:,:,:,np.newaxis] / 255

print(x_train.shape)
print(y_train.shape)
print(x_test.shape)
print(y_test.shape)

(60000, 28, 28, 1)
(60000,)
(10000, 28, 28, 1)
(10000,)

class_names = ['T-shirt/top', 'Trouser', 'Pullover', 'Dress', 'Coat',
               'Sandal', 'Shirt', 'Sneaker', 'Bag', 'Ankle boot']

모델 구성 및 학습

• 임의의 모델

def build_model():
    # 입력 레이어 정의
    input = Input(shape=(28,28,1))
    output = Conv2D(filters=32, kernel_size=3, activation='relu', padding='same')(input)
    output = Conv2D(filters=32, kernel_size=3, activation='relu', padding='same')(output)
    output = Conv2D(filters=32, kernel_size=3, activation='relu', padding='same')(output)

    # 평탄화와 완전 연결 레이어
    output = Flatten()(output)
    output = Dense(128, activation='relu')(output)
    output = Dense(64, activation='relu')(output)

    # 출력 레이어
    output = Dense(10, activation='softmax')(output)

    model = Model(inputs=[input], outputs=output)

    model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['acc'])

    return model

model_1 = build_model()
model_1.summary()

Model: "functional"

┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━┓
┃ Layer (type)                         ┃ Output Shape                ┃         Param # ┃
┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━┩
│ input_layer (InputLayer)             │ (None, 28, 28, 1)           │               0 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv2d (Conv2D)                      │ (None, 28, 28, 32)          │             320 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv2d_1 (Conv2D)                    │ (None, 28, 28, 32)          │           9,248 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv2d_2 (Conv2D)                    │ (None, 28, 28, 32)          │           9,248 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ flatten (Flatten)                    │ (None, 25088)               │               0 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ dense (Dense)                        │ (None, 128)                 │       3,211,392 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ dense_1 (Dense)                      │ (None, 64)                  │           8,256 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ dense_2 (Dense)                      │ (None, 10)                  │             650 │
└──────────────────────────────────────┴─────────────────────────────┴─────────────────┘

 Total params: 3,239,114 (12.36 MB)

 Trainable params: 3,239,114 (12.36 MB)

 Non-trainable params: 0 (0.00 B)

hist_1 = model_1.fit(x_train, y_train,
                     epochs=20,
                     validation_split=0.3,
                     batch_size=512)

Epoch 1/20
83/83 ━━━━━━━━━━━━━━━━━━━━ 13s 68ms/step - acc: 0.6512 - loss: 0.9781 - val_acc: 0.8304 - val_loss: 0.4678
Epoch 2/20
83/83 ━━━━━━━━━━━━━━━━━━━━ 3s 30ms/step - acc: 0.8564 - loss: 0.3977 - val_acc: 0.8658 - val_loss: 0.3770
Epoch 3/20
83/83 ━━━━━━━━━━━━━━━━━━━━ 3s 31ms/step - acc: 0.8847 - loss: 0.3199 - val_acc: 0.8898 - val_loss: 0.3059
Epoch 4/20
83/83 ━━━━━━━━━━━━━━━━━━━━ 3s 30ms/step - acc: 0.9049 - loss: 0.2574 - val_acc: 0.8946 - val_loss: 0.2976
Epoch 5/20
83/83 ━━━━━━━━━━━━━━━━━━━━ 5s 33ms/step - acc: 0.9172 - loss: 0.2230 - val_acc: 0.8961 - val_loss: 0.2930
Epoch 6/20
83/83 ━━━━━━━━━━━━━━━━━━━━ 3s 40ms/step - acc: 0.9273 - loss: 0.1986 - val_acc: 0.9093 - val_loss: 0.2612
Epoch 7/20
83/83 ━━━━━━━━━━━━━━━━━━━━ 3s 34ms/step - acc: 0.9399 - loss: 0.1639 - val_acc: 0.8875 - val_loss: 0.3520
Epoch 8/20
83/83 ━━━━━━━━━━━━━━━━━━━━ 5s 29ms/step - acc: 0.9346 - loss: 0.1766 - val_acc: 0.8737 - val_loss: 0.3914
Epoch 9/20
83/83 ━━━━━━━━━━━━━━━━━━━━ 2s 28ms/step - acc: 0.9398 - loss: 0.1657 - val_acc: 0.9060 - val_loss: 0.2923
Epoch 10/20
83/83 ━━━━━━━━━━━━━━━━━━━━ 3s 28ms/step - acc: 0.9608 - loss: 0.1113 - val_acc: 0.9093 - val_loss: 0.2991
Epoch 11/20
83/83 ━━━━━━━━━━━━━━━━━━━━ 3s 29ms/step - acc: 0.9657 - loss: 0.0964 - val_acc: 0.9070 - val_loss: 0.3465
Epoch 12/20
83/83 ━━━━━━━━━━━━━━━━━━━━ 3s 29ms/step - acc: 0.9699 - loss: 0.0851 - val_acc: 0.9096 - val_loss: 0.3286
Epoch 13/20
83/83 ━━━━━━━━━━━━━━━━━━━━ 2s 28ms/step - acc: 0.9814 - loss: 0.0536 - val_acc: 0.9056 - val_loss: 0.3904
Epoch 14/20
83/83 ━━━━━━━━━━━━━━━━━━━━ 2s 28ms/step - acc: 0.9776 - loss: 0.0685 - val_acc: 0.9146 - val_loss: 0.3694
Epoch 15/20
83/83 ━━━━━━━━━━━━━━━━━━━━ 2s 28ms/step - acc: 0.9920 - loss: 0.0262 - val_acc: 0.9105 - val_loss: 0.4255
Epoch 16/20
83/83 ━━━━━━━━━━━━━━━━━━━━ 2s 29ms/step - acc: 0.9878 - loss: 0.0361 - val_acc: 0.9142 - val_loss: 0.4280
Epoch 17/20
83/83 ━━━━━━━━━━━━━━━━━━━━ 3s 29ms/step - acc: 0.9955 - loss: 0.0153 - val_acc: 0.9119 - val_loss: 0.4758
Epoch 18/20
83/83 ━━━━━━━━━━━━━━━━━━━━ 2s 28ms/step - acc: 0.9964 - loss: 0.0120 - val_acc: 0.9134 - val_loss: 0.4914
Epoch 19/20
83/83 ━━━━━━━━━━━━━━━━━━━━ 3s 28ms/step - acc: 0.9976 - loss: 0.0086 - val_acc: 0.9142 - val_loss: 0.5214
Epoch 20/20
83/83 ━━━━━━━━━━━━━━━━━━━━ 2s 28ms/step - acc: 0.9989 - loss: 0.0054 - val_acc: 0.9144 - val_loss: 0.5490

hist_1.history.keys()

plt.figure(figsize=(12,4))
plt.subplot(1,2,1)
plt.plot(hist_1.history['loss'], 'b--', label='loss')
plt.plot(hist_1.history['val_loss'],'r:',label='val_loss')
plt.xlabel('Epochs')
plt.ylabel('Loss')
plt.grid()
plt.legend()

plt.subplot(1,2,2)
plt.plot(hist_1.history['acc'], 'b--', label='acc')
plt.plot(hist_1.history['val_acc'],'r:',label='val_acc')
plt.xlabel('Epochs')
plt.ylabel('accuracy')
plt.grid()
plt.legend()
plt.show()

model_1.evaluate(x_test, y_test)

313/313 ━━━━━━━━━━━━━━━━━━━━ 2s 3ms/step - acc: 0.9092 - loss: 0.6197





[0.602406919002533, 0.9063000082969666]

모델 구성 및 학습: 과대적합 방지

• 학습 파라미터의 수 비교

def build_model2():
    # 입력 레이어 정의
    input = Input(shape=(28,28,1))

    output = Conv2D(filters=32, kernel_size=3, activation='relu', padding='same')(input)
    output = MaxPooling2D(strides=2)(output)

    output = Conv2D(filters=32, kernel_size=3, activation='relu', padding='same')(output)
    output = MaxPooling2D(strides=2)(output)
    output = Dropout(0.4)(output)

    output = Conv2D(filters=32, kernel_size=3, activation='relu', padding='same')(output)
    output = Dropout(0.4)(output)

    # 평탄화와 완전 연결 레이어
    output = Flatten()(output)
    output = Dense(128, activation='relu')(output)
    output = Dense(64, activation='relu')(output)

    # 출력 레이어
    output = Dense(10, activation='softmax')(output)

    model = Model(inputs=[input], outputs=output)

    model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['acc'])

    return model

model_2 = build_model2()
model_2.summary()

Model: "functional_3"

┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━┓
┃ Layer (type)                         ┃ Output Shape                ┃         Param # ┃
┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━┩
│ input_layer_3 (InputLayer)           │ (None, 28, 28, 1)           │               0 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv2d_9 (Conv2D)                    │ (None, 28, 28, 32)          │             320 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ max_pooling2d_2 (MaxPooling2D)       │ (None, 14, 14, 32)          │               0 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv2d_10 (Conv2D)                   │ (None, 14, 14, 32)          │           9,248 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ max_pooling2d_3 (MaxPooling2D)       │ (None, 7, 7, 32)            │               0 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ dropout_2 (Dropout)                  │ (None, 7, 7, 32)            │               0 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv2d_11 (Conv2D)                   │ (None, 7, 7, 32)            │           9,248 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ dropout_3 (Dropout)                  │ (None, 7, 7, 32)            │               0 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ flatten_3 (Flatten)                  │ (None, 1568)                │               0 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ dense_9 (Dense)                      │ (None, 128)                 │         200,832 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ dense_10 (Dense)                     │ (None, 64)                  │           8,256 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ dense_11 (Dense)                     │ (None, 10)                  │             650 │
└──────────────────────────────────────┴─────────────────────────────┴─────────────────┘

 Total params: 228,554 (892.79 KB)

 Trainable params: 228,554 (892.79 KB)

 Non-trainable params: 0 (0.00 B)

hist_2 = model_2.fit(x_train, y_train,
                     epochs=40,
                     validation_split=0.3,
                     batch_size=512)

Epoch 1/40
83/83 ━━━━━━━━━━━━━━━━━━━━ 8s 59ms/step - acc: 0.5021 - loss: 1.4116 - val_acc: 0.7751 - val_loss: 0.5945
Epoch 2/40
83/83 ━━━━━━━━━━━━━━━━━━━━ 4s 11ms/step - acc: 0.7724 - loss: 0.5961 - val_acc: 0.8313 - val_loss: 0.4664
Epoch 3/40
83/83 ━━━━━━━━━━━━━━━━━━━━ 1s 10ms/step - acc: 0.8223 - loss: 0.4867 - val_acc: 0.8351 - val_loss: 0.4346
Epoch 4/40
83/83 ━━━━━━━━━━━━━━━━━━━━ 1s 11ms/step - acc: 0.8314 - loss: 0.4567 - val_acc: 0.8628 - val_loss: 0.3815
Epoch 5/40
83/83 ━━━━━━━━━━━━━━━━━━━━ 1s 10ms/step - acc: 0.8552 - loss: 0.4041 - val_acc: 0.8757 - val_loss: 0.3460
Epoch 6/40
83/83 ━━━━━━━━━━━━━━━━━━━━ 1s 12ms/step - acc: 0.8554 - loss: 0.3948 - val_acc: 0.8814 - val_loss: 0.3294
Epoch 7/40
83/83 ━━━━━━━━━━━━━━━━━━━━ 1s 12ms/step - acc: 0.8701 - loss: 0.3554 - val_acc: 0.8718 - val_loss: 0.3508
Epoch 8/40
83/83 ━━━━━━━━━━━━━━━━━━━━ 1s 11ms/step - acc: 0.8619 - loss: 0.3682 - val_acc: 0.8886 - val_loss: 0.3064
Epoch 9/40
83/83 ━━━━━━━━━━━━━━━━━━━━ 1s 11ms/step - acc: 0.8746 - loss: 0.3418 - val_acc: 0.8887 - val_loss: 0.3051
Epoch 10/40
83/83 ━━━━━━━━━━━━━━━━━━━━ 1s 10ms/step - acc: 0.8773 - loss: 0.3354 - val_acc: 0.8958 - val_loss: 0.2841
Epoch 11/40
83/83 ━━━━━━━━━━━━━━━━━━━━ 1s 11ms/step - acc: 0.8832 - loss: 0.3175 - val_acc: 0.8904 - val_loss: 0.2967
Epoch 12/40
83/83 ━━━━━━━━━━━━━━━━━━━━ 1s 10ms/step - acc: 0.8809 - loss: 0.3196 - val_acc: 0.8974 - val_loss: 0.2780
Epoch 13/40
83/83 ━━━━━━━━━━━━━━━━━━━━ 1s 11ms/step - acc: 0.8830 - loss: 0.3095 - val_acc: 0.9017 - val_loss: 0.2681
Epoch 14/40
83/83 ━━━━━━━━━━━━━━━━━━━━ 1s 12ms/step - acc: 0.8900 - loss: 0.2956 - val_acc: 0.9008 - val_loss: 0.2671
Epoch 15/40
83/83 ━━━━━━━━━━━━━━━━━━━━ 1s 10ms/step - acc: 0.8896 - loss: 0.2998 - val_acc: 0.8984 - val_loss: 0.2735
Epoch 16/40
83/83 ━━━━━━━━━━━━━━━━━━━━ 1s 10ms/step - acc: 0.8942 - loss: 0.2825 - val_acc: 0.9066 - val_loss: 0.2590
Epoch 17/40
83/83 ━━━━━━━━━━━━━━━━━━━━ 1s 10ms/step - acc: 0.8918 - loss: 0.2820 - val_acc: 0.9088 - val_loss: 0.2516
Epoch 18/40
83/83 ━━━━━━━━━━━━━━━━━━━━ 1s 11ms/step - acc: 0.8960 - loss: 0.2823 - val_acc: 0.8995 - val_loss: 0.2668
Epoch 19/40
83/83 ━━━━━━━━━━━━━━━━━━━━ 1s 15ms/step - acc: 0.8983 - loss: 0.2699 - val_acc: 0.9087 - val_loss: 0.2475
Epoch 20/40
83/83 ━━━━━━━━━━━━━━━━━━━━ 1s 13ms/step - acc: 0.9016 - loss: 0.2681 - val_acc: 0.9141 - val_loss: 0.2390
Epoch 21/40
83/83 ━━━━━━━━━━━━━━━━━━━━ 1s 10ms/step - acc: 0.9043 - loss: 0.2582 - val_acc: 0.9126 - val_loss: 0.2389
Epoch 22/40
83/83 ━━━━━━━━━━━━━━━━━━━━ 1s 10ms/step - acc: 0.8995 - loss: 0.2648 - val_acc: 0.9127 - val_loss: 0.2425
Epoch 23/40
83/83 ━━━━━━━━━━━━━━━━━━━━ 1s 10ms/step - acc: 0.9019 - loss: 0.2676 - val_acc: 0.9166 - val_loss: 0.2280
Epoch 24/40
83/83 ━━━━━━━━━━━━━━━━━━━━ 1s 10ms/step - acc: 0.9075 - loss: 0.2469 - val_acc: 0.9136 - val_loss: 0.2336
Epoch 25/40
83/83 ━━━━━━━━━━━━━━━━━━━━ 1s 10ms/step - acc: 0.9107 - loss: 0.2395 - val_acc: 0.9155 - val_loss: 0.2313
Epoch 26/40
83/83 ━━━━━━━━━━━━━━━━━━━━ 1s 10ms/step - acc: 0.9138 - loss: 0.2304 - val_acc: 0.9148 - val_loss: 0.2368
Epoch 27/40
83/83 ━━━━━━━━━━━━━━━━━━━━ 1s 10ms/step - acc: 0.9100 - loss: 0.2364 - val_acc: 0.9172 - val_loss: 0.2285
Epoch 28/40
83/83 ━━━━━━━━━━━━━━━━━━━━ 1s 11ms/step - acc: 0.9080 - loss: 0.2471 - val_acc: 0.9198 - val_loss: 0.2229
Epoch 29/40
83/83 ━━━━━━━━━━━━━━━━━━━━ 1s 16ms/step - acc: 0.9121 - loss: 0.2334 - val_acc: 0.9174 - val_loss: 0.2269
Epoch 30/40
83/83 ━━━━━━━━━━━━━━━━━━━━ 2s 11ms/step - acc: 0.9122 - loss: 0.2322 - val_acc: 0.9189 - val_loss: 0.2228
Epoch 31/40
83/83 ━━━━━━━━━━━━━━━━━━━━ 1s 10ms/step - acc: 0.9086 - loss: 0.2378 - val_acc: 0.9204 - val_loss: 0.2224
Epoch 32/40
83/83 ━━━━━━━━━━━━━━━━━━━━ 1s 10ms/step - acc: 0.9131 - loss: 0.2292 - val_acc: 0.9209 - val_loss: 0.2198
Epoch 33/40
83/83 ━━━━━━━━━━━━━━━━━━━━ 1s 13ms/step - acc: 0.9154 - loss: 0.2256 - val_acc: 0.9201 - val_loss: 0.2189
Epoch 34/40
83/83 ━━━━━━━━━━━━━━━━━━━━ 1s 12ms/step - acc: 0.9153 - loss: 0.2237 - val_acc: 0.9161 - val_loss: 0.2290
Epoch 35/40
83/83 ━━━━━━━━━━━━━━━━━━━━ 1s 11ms/step - acc: 0.9155 - loss: 0.2244 - val_acc: 0.9221 - val_loss: 0.2133
Epoch 36/40
83/83 ━━━━━━━━━━━━━━━━━━━━ 1s 10ms/step - acc: 0.9209 - loss: 0.2112 - val_acc: 0.9229 - val_loss: 0.2155
Epoch 37/40
83/83 ━━━━━━━━━━━━━━━━━━━━ 1s 10ms/step - acc: 0.9238 - loss: 0.2039 - val_acc: 0.9199 - val_loss: 0.2152
Epoch 38/40
83/83 ━━━━━━━━━━━━━━━━━━━━ 1s 10ms/step - acc: 0.9188 - loss: 0.2157 - val_acc: 0.9222 - val_loss: 0.2143
Epoch 39/40
83/83 ━━━━━━━━━━━━━━━━━━━━ 1s 10ms/step - acc: 0.9239 - loss: 0.2039 - val_acc: 0.9150 - val_loss: 0.2285
Epoch 40/40
83/83 ━━━━━━━━━━━━━━━━━━━━ 1s 11ms/step - acc: 0.9230 - loss: 0.2062 - val_acc: 0.9222 - val_loss: 0.2114

hist_2.history.keys()

plt.figure(figsize=(12,4))
plt.subplot(1,2,1)
plt.plot(hist_2.history['loss'], 'b--', label='loss')
plt.plot(hist_2.history['val_loss'],'r:',label='val_loss')
plt.xlabel('Epochs')
plt.ylabel('Loss')
plt.grid()
plt.legend()

plt.subplot(1,2,2)
plt.plot(hist_2.history['acc'], 'b--', label='acc')
plt.plot(hist_2.history['val_acc'],'r:',label='val_acc')
plt.xlabel('Epochs')
plt.ylabel('accuracy')
plt.grid()
plt.legend()
plt.show()

model_2.evaluate(x_test, y_test) # 학습시간 감소 및 과적합 방지

313/313 ━━━━━━━━━━━━━━━━━━━━ 2s 4ms/step - acc: 0.9150 - loss: 0.2314





[0.22845305502414703, 0.9151999950408936]

모델 성능 높이기: 레이어 추가

# 배치마다 층의 출력을 정규화하여 학습을 안정화하고 속도를 높이며, 과적합을 줄이는 효과
# 평균이 0, 표준편차가 1이 되도록 변형
from tensorflow.keras.layers import BatchNormalization

def build_model3():
    # 입력 레이어 정의
    input = Input(shape=(28,28,1))

    output = Conv2D(filters=32, kernel_size=3, activation='relu', padding='same')(input)
    output = BatchNormalization()(output)
    output = MaxPooling2D(strides=2)(output)

    output = Conv2D(filters=64, kernel_size=3, activation='relu', padding='valid')(output)
    output = BatchNormalization()(output)
    output = MaxPooling2D(strides=2)(output)
    output = Dropout(0.4)(output)

    output = Conv2D(filters=128, kernel_size=3, activation='relu', padding='same')(output)
    output = Dropout(0.4)(output)

    # 평탄화와 완전 연결 레이어
    output = Flatten()(output)
    output = Dense(512, activation='relu')(output)
    output = BatchNormalization()(output)
    output = Dense(256, activation='relu')(output)
    output = BatchNormalization()(output)

    # 출력 레이어
    output = Dense(10, activation='softmax')(output)

    model = Model(inputs=[input], outputs=output)

    model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['acc'])

    return model

model_3 = build_model3()
model_3.summary()

Model: "functional_5"

┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━┓
┃ Layer (type)                         ┃ Output Shape                ┃         Param # ┃
┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━┩
│ input_layer_5 (InputLayer)           │ (None, 28, 28, 1)           │               0 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv2d_15 (Conv2D)                   │ (None, 28, 28, 32)          │             320 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ batch_normalization_4                │ (None, 28, 28, 32)          │             128 │
│ (BatchNormalization)                 │                             │                 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ max_pooling2d_6 (MaxPooling2D)       │ (None, 14, 14, 32)          │               0 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv2d_16 (Conv2D)                   │ (None, 12, 12, 64)          │          18,496 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ batch_normalization_5                │ (None, 12, 12, 64)          │             256 │
│ (BatchNormalization)                 │                             │                 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ max_pooling2d_7 (MaxPooling2D)       │ (None, 6, 6, 64)            │               0 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ dropout_6 (Dropout)                  │ (None, 6, 6, 64)            │               0 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv2d_17 (Conv2D)                   │ (None, 6, 6, 128)           │          73,856 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ dropout_7 (Dropout)                  │ (None, 6, 6, 128)           │               0 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ flatten_5 (Flatten)                  │ (None, 4608)                │               0 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ dense_15 (Dense)                     │ (None, 512)                 │       2,359,808 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ batch_normalization_6                │ (None, 512)                 │           2,048 │
│ (BatchNormalization)                 │                             │                 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ dense_16 (Dense)                     │ (None, 256)                 │         131,328 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ batch_normalization_7                │ (None, 256)                 │           1,024 │
│ (BatchNormalization)                 │                             │                 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ dense_17 (Dense)                     │ (None, 10)                  │           2,570 │
└──────────────────────────────────────┴─────────────────────────────┴─────────────────┘

 Total params: 2,589,834 (9.88 MB)

 Trainable params: 2,588,106 (9.87 MB)

 Non-trainable params: 1,728 (6.75 KB)

hist_3 = model_3.fit(x_train, y_train,
                     epochs=40,
                     validation_split=0.3,
                     batch_size=512)

Epoch 1/40
83/83 ━━━━━━━━━━━━━━━━━━━━ 21s 160ms/step - acc: 0.7350 - loss: 0.7634 - val_acc: 0.1299 - val_loss: 2.7767
Epoch 2/40
83/83 ━━━━━━━━━━━━━━━━━━━━ 1s 16ms/step - acc: 0.8582 - loss: 0.3842 - val_acc: 0.3571 - val_loss: 2.5578
Epoch 3/40
83/83 ━━━━━━━━━━━━━━━━━━━━ 1s 16ms/step - acc: 0.8845 - loss: 0.3142 - val_acc: 0.4129 - val_loss: 1.9564
Epoch 4/40
83/83 ━━━━━━━━━━━━━━━━━━━━ 3s 17ms/step - acc: 0.8887 - loss: 0.2980 - val_acc: 0.6051 - val_loss: 1.2800
Epoch 5/40
83/83 ━━━━━━━━━━━━━━━━━━━━ 2s 19ms/step - acc: 0.8991 - loss: 0.2685 - val_acc: 0.7246 - val_loss: 0.7777
Epoch 6/40
83/83 ━━━━━━━━━━━━━━━━━━━━ 2s 20ms/step - acc: 0.9092 - loss: 0.2384 - val_acc: 0.7784 - val_loss: 0.6222
Epoch 7/40
83/83 ━━━━━━━━━━━━━━━━━━━━ 2s 17ms/step - acc: 0.9110 - loss: 0.2406 - val_acc: 0.8777 - val_loss: 0.3326
Epoch 8/40
83/83 ━━━━━━━━━━━━━━━━━━━━ 3s 17ms/step - acc: 0.9180 - loss: 0.2145 - val_acc: 0.9142 - val_loss: 0.2361
Epoch 9/40
83/83 ━━━━━━━━━━━━━━━━━━━━ 1s 17ms/step - acc: 0.9120 - loss: 0.2314 - val_acc: 0.9153 - val_loss: 0.2320
Epoch 10/40
83/83 ━━━━━━━━━━━━━━━━━━━━ 3s 17ms/step - acc: 0.9286 - loss: 0.1951 - val_acc: 0.9119 - val_loss: 0.2439
Epoch 11/40
83/83 ━━━━━━━━━━━━━━━━━━━━ 2s 19ms/step - acc: 0.9304 - loss: 0.1859 - val_acc: 0.9118 - val_loss: 0.2508
Epoch 12/40
83/83 ━━━━━━━━━━━━━━━━━━━━ 3s 23ms/step - acc: 0.9236 - loss: 0.2017 - val_acc: 0.8492 - val_loss: 0.4852
Epoch 13/40
83/83 ━━━━━━━━━━━━━━━━━━━━ 2s 17ms/step - acc: 0.9318 - loss: 0.1800 - val_acc: 0.9248 - val_loss: 0.2186
Epoch 14/40
83/83 ━━━━━━━━━━━━━━━━━━━━ 3s 17ms/step - acc: 0.9301 - loss: 0.1841 - val_acc: 0.9146 - val_loss: 0.2461
Epoch 15/40
83/83 ━━━━━━━━━━━━━━━━━━━━ 3s 17ms/step - acc: 0.9372 - loss: 0.1692 - val_acc: 0.9279 - val_loss: 0.2054
Epoch 16/40
83/83 ━━━━━━━━━━━━━━━━━━━━ 3s 18ms/step - acc: 0.9417 - loss: 0.1566 - val_acc: 0.9127 - val_loss: 0.2526
Epoch 17/40
83/83 ━━━━━━━━━━━━━━━━━━━━ 2s 19ms/step - acc: 0.9340 - loss: 0.1773 - val_acc: 0.8458 - val_loss: 0.5771
Epoch 18/40
83/83 ━━━━━━━━━━━━━━━━━━━━ 2s 18ms/step - acc: 0.9166 - loss: 0.2161 - val_acc: 0.8932 - val_loss: 0.3014
Epoch 19/40
83/83 ━━━━━━━━━━━━━━━━━━━━ 1s 17ms/step - acc: 0.9365 - loss: 0.1630 - val_acc: 0.9253 - val_loss: 0.2123
Epoch 20/40
83/83 ━━━━━━━━━━━━━━━━━━━━ 3s 17ms/step - acc: 0.9461 - loss: 0.1421 - val_acc: 0.9290 - val_loss: 0.2070
Epoch 21/40
83/83 ━━━━━━━━━━━━━━━━━━━━ 3s 19ms/step - acc: 0.9450 - loss: 0.1443 - val_acc: 0.9127 - val_loss: 0.2592
Epoch 22/40
83/83 ━━━━━━━━━━━━━━━━━━━━ 3s 19ms/step - acc: 0.9522 - loss: 0.1256 - val_acc: 0.9237 - val_loss: 0.2341
Epoch 23/40
83/83 ━━━━━━━━━━━━━━━━━━━━ 2s 18ms/step - acc: 0.9516 - loss: 0.1296 - val_acc: 0.9283 - val_loss: 0.2085
Epoch 24/40
83/83 ━━━━━━━━━━━━━━━━━━━━ 2s 19ms/step - acc: 0.9526 - loss: 0.1224 - val_acc: 0.9123 - val_loss: 0.2683
Epoch 25/40
83/83 ━━━━━━━━━━━━━━━━━━━━ 2s 20ms/step - acc: 0.9501 - loss: 0.1317 - val_acc: 0.9276 - val_loss: 0.2233
Epoch 26/40
83/83 ━━━━━━━━━━━━━━━━━━━━ 1s 17ms/step - acc: 0.9536 - loss: 0.1240 - val_acc: 0.9330 - val_loss: 0.2050
Epoch 27/40
83/83 ━━━━━━━━━━━━━━━━━━━━ 1s 17ms/step - acc: 0.9594 - loss: 0.1083 - val_acc: 0.9297 - val_loss: 0.2211
Epoch 28/40
83/83 ━━━━━━━━━━━━━━━━━━━━ 1s 17ms/step - acc: 0.9623 - loss: 0.1014 - val_acc: 0.9193 - val_loss: 0.2532
Epoch 29/40
83/83 ━━━━━━━━━━━━━━━━━━━━ 3s 17ms/step - acc: 0.9594 - loss: 0.1092 - val_acc: 0.9223 - val_loss: 0.2487
Epoch 30/40
83/83 ━━━━━━━━━━━━━━━━━━━━ 2s 19ms/step - acc: 0.9532 - loss: 0.1246 - val_acc: 0.9099 - val_loss: 0.2844
Epoch 31/40
83/83 ━━━━━━━━━━━━━━━━━━━━ 2s 20ms/step - acc: 0.9551 - loss: 0.1161 - val_acc: 0.9290 - val_loss: 0.2255
Epoch 32/40
83/83 ━━━━━━━━━━━━━━━━━━━━ 1s 17ms/step - acc: 0.9599 - loss: 0.1057 - val_acc: 0.9151 - val_loss: 0.2691
Epoch 33/40
83/83 ━━━━━━━━━━━━━━━━━━━━ 2s 19ms/step - acc: 0.9633 - loss: 0.0979 - val_acc: 0.9321 - val_loss: 0.2323
Epoch 34/40
83/83 ━━━━━━━━━━━━━━━━━━━━ 2s 17ms/step - acc: 0.9697 - loss: 0.0833 - val_acc: 0.9201 - val_loss: 0.2688
Epoch 35/40
83/83 ━━━━━━━━━━━━━━━━━━━━ 1s 17ms/step - acc: 0.9483 - loss: 0.1393 - val_acc: 0.9292 - val_loss: 0.2192
Epoch 36/40
83/83 ━━━━━━━━━━━━━━━━━━━━ 3s 19ms/step - acc: 0.9514 - loss: 0.1292 - val_acc: 0.9185 - val_loss: 0.2540
Epoch 37/40
83/83 ━━━━━━━━━━━━━━━━━━━━ 1s 18ms/step - acc: 0.9528 - loss: 0.1289 - val_acc: 0.9311 - val_loss: 0.2254
Epoch 38/40
83/83 ━━━━━━━━━━━━━━━━━━━━ 2s 18ms/step - acc: 0.9658 - loss: 0.0902 - val_acc: 0.9335 - val_loss: 0.2218
Epoch 39/40
83/83 ━━━━━━━━━━━━━━━━━━━━ 3s 19ms/step - acc: 0.9708 - loss: 0.0772 - val_acc: 0.9358 - val_loss: 0.2119
Epoch 40/40
83/83 ━━━━━━━━━━━━━━━━━━━━ 1s 17ms/step - acc: 0.9703 - loss: 0.0761 - val_acc: 0.9302 - val_loss: 0.2325

hist_3.history.keys()

plt.figure(figsize=(12,4))
plt.subplot(1,2,1)
plt.plot(hist_3.history['loss'], 'b--', label='loss')
plt.plot(hist_3.history['val_loss'],'r:',label='val_loss')
plt.xlabel('Epochs')
plt.ylabel('Loss')
plt.grid()
plt.legend()

plt.subplot(1,2,2)
plt.plot(hist_3.history['acc'], 'b--', label='acc')
plt.plot(hist_3.history['val_acc'],'r:',label='val_acc')
plt.xlabel('Epochs')
plt.ylabel('accuracy')
plt.grid()
plt.legend()
plt.show()

model_3.evaluate(x_test, y_test) # 학습시간 감소 및 과적합 방지

313/313 ━━━━━━━━━━━━━━━━━━━━ 2s 3ms/step - acc: 0.9212 - loss: 0.2699





[0.2635417580604553, 0.9228000044822693]

• 과대적합은 되지 않았고, 층을 늘려도 좋은 성능을 낼 수 있음

모델 성능 높이기: 이미지 보강(Image Augmentation)

• 주요 인자 참고: https://keras.io/ko/preprocessing/image/

from tensorflow.keras.preprocessing.image import ImageDataGenerator

image_generator = ImageDataGenerator(
    rotation_range=10,         # 이미지를 무작위로 최대 10도까지 회전
    zoom_range=0.2,            # 이미지를 무작위로 최대 20%까지 확대 또는 축소
    shear_range=0.7,           # 이미지를 무작위로 최대 0.7 라디안만큼 시프트
    width_shift_range=0.1,     # 이미지를 좌우로 최대 10%까지 이동
    height_shift_range=0.1,    # 이미지를 상하로 최대 10%까지 이동
    horizontal_flip=True,      # 이미지를 좌우로 무작위로 뒤집음
    vertical_flip=False        # 이미지를 상하로 뒤집지 않음
)

augment_size = 200
print(x_train.shape)
print(x_train[0].shape)

(60000, 28, 28, 1)
(28, 28, 1)

x_augment = image_generator.flow(
    x_train[:augment_size],
    batch_size=augment_size, # 한 번에 200개 이미지를 반환
    shuffle=False # 데이터를 무작위로 섞지 않고 원래 순서를 유지
    )

# 1개 이미지에 대한 증강 예시
# 여러 이미지로 할거면 x_augment[0][i]로 수정
plt.figure(figsize=(10,10))
for i in range(1,11):
    plt.subplot(1,10,i)
    plt.imshow(x_augment[0][0], cmap='gray')
    plt.axis('off')
plt.show()

데이터 추가

image_generator = ImageDataGenerator(
    rotation_range=15,         # 이미지를 무작위로 최대 10도까지 회전
    zoom_range=0.1,            # 이미지를 무작위로 최대 20%까지 확대 또는 축소
    shear_range=0.6,           # 이미지를 무작위로 최대 0.7 라디안만큼 시프트
    width_shift_range=0.1,     # 이미지를 좌우로 최대 10%까지 이동
    height_shift_range=0.1,    # 이미지를 상하로 최대 10%까지 이동
    horizontal_flip=True,      # 이미지를 좌우로 무작위로 뒤집음
    vertical_flip=False        # 이미지를 상하로 뒤집지 않음
)

augment_size = 20000

# x_train에서 10000개 샘플을 무작위로 선택
indices = np.random.permutation(len(x_train))[:20000]
x_sample = x_train[indices]

x_augmented = image_generator.flow(
    x_sample,           # 증강할 데이터 샘플
    batch_size=augment_size,  # 배치 크기: 한 번에 20000개 이미지 반환
    shuffle=False       # 데이터를 섞지 않고 원래 순서대로 반환
)

x_augmented = next(x_augmented)
y_augmented = y_train[indices]

x_train = np.concatenate((x_train, x_augmented))
y_train = np.concatenate((y_train, y_augmented))

print(x_train.shape)
print(y_train.shape)

(90000, 28, 28, 1)
(90000,)

x_augmented = image_generator.flow(
    x_sample[:1000],           # 증강할 데이터 샘플
    batch_size=10,  # 배치 크기: 한 번에 20000개 이미지 반환
    shuffle=False       # 데이터를 섞지 않고 원래 순서대로 반환
)
x_augmented = next(x_augmented)
x_augmented.shape

(10, 28, 28, 1)

model_4 = build_model3()
model_4.summary()

Model: "functional"

┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━┓
┃ Layer (type)                         ┃ Output Shape                ┃         Param # ┃
┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━┩
│ input_layer_1 (InputLayer)           │ (None, 28, 28, 1)           │               0 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv2d_1 (Conv2D)                    │ (None, 28, 28, 32)          │             320 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ batch_normalization                  │ (None, 28, 28, 32)          │             128 │
│ (BatchNormalization)                 │                             │                 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ max_pooling2d (MaxPooling2D)         │ (None, 14, 14, 32)          │               0 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv2d_2 (Conv2D)                    │ (None, 12, 12, 64)          │          18,496 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ batch_normalization_1                │ (None, 12, 12, 64)          │             256 │
│ (BatchNormalization)                 │                             │                 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ max_pooling2d_1 (MaxPooling2D)       │ (None, 6, 6, 64)            │               0 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ dropout (Dropout)                    │ (None, 6, 6, 64)            │               0 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv2d_3 (Conv2D)                    │ (None, 6, 6, 128)           │          73,856 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ dropout_1 (Dropout)                  │ (None, 6, 6, 128)           │               0 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ flatten (Flatten)                    │ (None, 4608)                │               0 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ dense (Dense)                        │ (None, 512)                 │       2,359,808 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ batch_normalization_2                │ (None, 512)                 │           2,048 │
│ (BatchNormalization)                 │                             │                 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ dense_1 (Dense)                      │ (None, 256)                 │         131,328 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ batch_normalization_3                │ (None, 256)                 │           1,024 │
│ (BatchNormalization)                 │                             │                 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ dense_2 (Dense)                      │ (None, 10)                  │           2,570 │
└──────────────────────────────────────┴─────────────────────────────┴─────────────────┘

 Total params: 2,589,834 (9.88 MB)

 Trainable params: 2,588,106 (9.87 MB)

 Non-trainable params: 1,728 (6.75 KB)

hist_4 = model_4.fit(x_train, y_train,
                     epochs=40,
                     validation_split=0.3,
                     batch_size=512)

Epoch 1/40
124/124 ━━━━━━━━━━━━━━━━━━━━ 34s 184ms/step - acc: 0.7523 - loss: 0.7219 - val_acc: 0.0992 - val_loss: 3.1442
Epoch 2/40
124/124 ━━━━━━━━━━━━━━━━━━━━ 13s 18ms/step - acc: 0.8723 - loss: 0.3486 - val_acc: 0.2008 - val_loss: 2.4828
Epoch 3/40
124/124 ━━━━━━━━━━━━━━━━━━━━ 2s 16ms/step - acc: 0.8899 - loss: 0.2960 - val_acc: 0.3189 - val_loss: 1.9961
Epoch 4/40
124/124 ━━━━━━━━━━━━━━━━━━━━ 2s 17ms/step - acc: 0.8967 - loss: 0.2757 - val_acc: 0.6415 - val_loss: 0.9980
Epoch 5/40
124/124 ━━━━━━━━━━━━━━━━━━━━ 2s 17ms/step - acc: 0.9052 - loss: 0.2499 - val_acc: 0.7106 - val_loss: 0.8654
Epoch 6/40
124/124 ━━━━━━━━━━━━━━━━━━━━ 2s 16ms/step - acc: 0.9090 - loss: 0.2404 - val_acc: 0.7913 - val_loss: 0.5495
Epoch 7/40
124/124 ━━━━━━━━━━━━━━━━━━━━ 2s 17ms/step - acc: 0.9149 - loss: 0.2268 - val_acc: 0.7949 - val_loss: 0.5521
Epoch 8/40
124/124 ━━━━━━━━━━━━━━━━━━━━ 2s 16ms/step - acc: 0.9221 - loss: 0.2066 - val_acc: 0.8007 - val_loss: 0.5301
Epoch 9/40
124/124 ━━━━━━━━━━━━━━━━━━━━ 3s 16ms/step - acc: 0.9266 - loss: 0.1929 - val_acc: 0.8075 - val_loss: 0.5180
Epoch 10/40
124/124 ━━━━━━━━━━━━━━━━━━━━ 2s 18ms/step - acc: 0.9203 - loss: 0.2103 - val_acc: 0.7842 - val_loss: 0.6006
Epoch 11/40
124/124 ━━━━━━━━━━━━━━━━━━━━ 3s 27ms/step - acc: 0.9272 - loss: 0.1967 - val_acc: 0.7857 - val_loss: 0.5904
Epoch 12/40
124/124 ━━━━━━━━━━━━━━━━━━━━ 4s 18ms/step - acc: 0.9290 - loss: 0.1888 - val_acc: 0.7979 - val_loss: 0.5497
Epoch 13/40
124/124 ━━━━━━━━━━━━━━━━━━━━ 2s 17ms/step - acc: 0.9324 - loss: 0.1761 - val_acc: 0.8160 - val_loss: 0.5017
Epoch 14/40
124/124 ━━━━━━━━━━━━━━━━━━━━ 3s 17ms/step - acc: 0.9391 - loss: 0.1584 - val_acc: 0.8068 - val_loss: 0.5432
Epoch 15/40
124/124 ━━━━━━━━━━━━━━━━━━━━ 2s 17ms/step - acc: 0.9387 - loss: 0.1629 - val_acc: 0.7942 - val_loss: 0.5781
Epoch 16/40
124/124 ━━━━━━━━━━━━━━━━━━━━ 2s 17ms/step - acc: 0.9389 - loss: 0.1612 - val_acc: 0.7939 - val_loss: 0.5850
Epoch 17/40
124/124 ━━━━━━━━━━━━━━━━━━━━ 3s 17ms/step - acc: 0.9422 - loss: 0.1505 - val_acc: 0.7552 - val_loss: 0.7547
Epoch 18/40
124/124 ━━━━━━━━━━━━━━━━━━━━ 2s 16ms/step - acc: 0.9452 - loss: 0.1445 - val_acc: 0.7646 - val_loss: 0.6880
Epoch 19/40
124/124 ━━━━━━━━━━━━━━━━━━━━ 2s 16ms/step - acc: 0.9440 - loss: 0.1467 - val_acc: 0.7863 - val_loss: 0.6695
Epoch 20/40
124/124 ━━━━━━━━━━━━━━━━━━━━ 2s 18ms/step - acc: 0.9511 - loss: 0.1321 - val_acc: 0.8042 - val_loss: 0.5792
Epoch 21/40
124/124 ━━━━━━━━━━━━━━━━━━━━ 2s 18ms/step - acc: 0.9557 - loss: 0.1169 - val_acc: 0.8122 - val_loss: 0.5416
Epoch 22/40
124/124 ━━━━━━━━━━━━━━━━━━━━ 2s 16ms/step - acc: 0.9530 - loss: 0.1261 - val_acc: 0.8137 - val_loss: 0.5474
Epoch 23/40
124/124 ━━━━━━━━━━━━━━━━━━━━ 3s 17ms/step - acc: 0.9564 - loss: 0.1176 - val_acc: 0.8146 - val_loss: 0.5623
Epoch 24/40
124/124 ━━━━━━━━━━━━━━━━━━━━ 3s 16ms/step - acc: 0.9588 - loss: 0.1094 - val_acc: 0.8151 - val_loss: 0.5554
Epoch 25/40
124/124 ━━━━━━━━━━━━━━━━━━━━ 3s 18ms/step - acc: 0.9576 - loss: 0.1109 - val_acc: 0.7866 - val_loss: 0.7532
Epoch 26/40
124/124 ━━━━━━━━━━━━━━━━━━━━ 2s 17ms/step - acc: 0.9547 - loss: 0.1175 - val_acc: 0.7893 - val_loss: 0.7020
Epoch 27/40
124/124 ━━━━━━━━━━━━━━━━━━━━ 2s 16ms/step - acc: 0.9541 - loss: 0.1183 - val_acc: 0.8107 - val_loss: 0.5805
Epoch 28/40
124/124 ━━━━━━━━━━━━━━━━━━━━ 2s 16ms/step - acc: 0.9624 - loss: 0.0984 - val_acc: 0.8139 - val_loss: 0.5872
Epoch 29/40
124/124 ━━━━━━━━━━━━━━━━━━━━ 2s 17ms/step - acc: 0.9615 - loss: 0.0991 - val_acc: 0.8057 - val_loss: 0.6517
Epoch 30/40
124/124 ━━━━━━━━━━━━━━━━━━━━ 2s 17ms/step - acc: 0.9671 - loss: 0.0884 - val_acc: 0.8136 - val_loss: 0.6044
Epoch 31/40
124/124 ━━━━━━━━━━━━━━━━━━━━ 2s 18ms/step - acc: 0.9662 - loss: 0.0898 - val_acc: 0.7320 - val_loss: 1.0154
Epoch 32/40
124/124 ━━━━━━━━━━━━━━━━━━━━ 2s 17ms/step - acc: 0.9406 - loss: 0.1630 - val_acc: 0.8024 - val_loss: 0.6433
Epoch 33/40
124/124 ━━━━━━━━━━━━━━━━━━━━ 2s 17ms/step - acc: 0.9539 - loss: 0.1209 - val_acc: 0.7805 - val_loss: 0.7357
Epoch 34/40
124/124 ━━━━━━━━━━━━━━━━━━━━ 3s 17ms/step - acc: 0.9554 - loss: 0.1195 - val_acc: 0.8030 - val_loss: 0.6776
Epoch 35/40
124/124 ━━━━━━━━━━━━━━━━━━━━ 2s 16ms/step - acc: 0.9591 - loss: 0.1081 - val_acc: 0.8242 - val_loss: 0.5672
Epoch 36/40
124/124 ━━━━━━━━━━━━━━━━━━━━ 3s 17ms/step - acc: 0.9648 - loss: 0.0918 - val_acc: 0.8075 - val_loss: 0.6650
Epoch 37/40
124/124 ━━━━━━━━━━━━━━━━━━━━ 2s 17ms/step - acc: 0.9717 - loss: 0.0742 - val_acc: 0.8067 - val_loss: 0.6721
Epoch 38/40
124/124 ━━━━━━━━━━━━━━━━━━━━ 3s 16ms/step - acc: 0.9686 - loss: 0.0815 - val_acc: 0.8218 - val_loss: 0.5832
Epoch 39/40
124/124 ━━━━━━━━━━━━━━━━━━━━ 2s 17ms/step - acc: 0.9724 - loss: 0.0747 - val_acc: 0.8110 - val_loss: 0.7081
Epoch 40/40
124/124 ━━━━━━━━━━━━━━━━━━━━ 2s 16ms/step - acc: 0.9747 - loss: 0.0675 - val_acc: 0.7956 - val_loss: 0.7368

• 학습 인자를 이전과 다르게 주면서 학습하면 더 잘 나올것으로 판단

hist_4.history.keys()

plt.figure(figsize=(12,4))
plt.subplot(1,2,1)
plt.plot(hist_4.history['loss'], 'b--', label='loss')
plt.plot(hist_4.history['val_loss'],'r:',label='val_loss')
plt.xlabel('Epochs')
plt.ylabel('Loss')
plt.grid()
plt.legend()

plt.subplot(1,2,2)
plt.plot(hist_4.history['acc'], 'b--', label='acc')
plt.plot(hist_4.history['val_acc'],'r:',label='val_acc')
plt.xlabel('Epochs')
plt.ylabel('accuracy')
plt.grid()
plt.legend()
plt.show()

model_4.evaluate(x_test, y_test) # 학습시간 감소 및 과적합 방지

313/313 ━━━━━━━━━━━━━━━━━━━━ 3s 5ms/step - acc: 0.9187 - loss: 0.2915





[0.28360623121261597, 0.9200999736785889]

CIFAR-10

• CIFAR-10
  • 10개의 클래스로 구분된 32 x 32 사물 사진을 모은 데이터셋
  • 50,000개의 학습데이터, 10,000개의 테스트 데이터로 구성
  • 데이터 복잡도가 MNIST보다 훨씬 높은 특징이 있음
    • 단순한 신경망으로 특징을 검출하기 어려움

모듈 임포트

from tensorflow.keras.datasets import cifar10
from tensorflow.keras.layers import Conv2D, MaxPool2D, Dense, Input, Dropout, BatchNormalization
from tensorflow.keras.models import Sequential, Model
from tensorflow.keras.optimizers import Adam, SGD
from tensorflow.keras.callbacks import EarlyStopping
from tensorflow.keras.utils import to_categorical

from sklearn.model_selection import train_test_split
import numpy as np
import matplotlib.pyplot as plt

데이터 로드 및 전처리

(x_train_full, y_train_full), (x_test, y_test) = cifar10.load_data()

print(x_train_full.shape)
print(y_train_full.shape)
print(x_test.shape)
print(y_test.shape)

(50000, 32, 32, 3)
(50000, 1)
(10000, 32, 32, 3)
(10000, 1)

class_names = ['airplane', 'automobile', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck']

import random
plt.figure(figsize=(10, 5))
for i in range(10):
    plt.subplot(2, 5, i+1)
    plt.xticks([])
    plt.yticks([])
    plt.grid(False)
    idx = random.randint(1,50000)
    plt.imshow(x_train_full[idx])
    plt.xlabel(class_names[y_train_full[idx][0]])

# x_train_full 데이터셋의 각 채널에 대한 평균을 계산
x_mean = np.mean(x_train_full, axis=(0,1,2)) # array([125.30691805, 122.95039414, 113.86538318])
# x_train_full 데이터셋의 각 채널에 대한 표준편차를 계산
x_std = np.std(x_train_full, axis=(0,1,2))

# 훈련 데이터를 정규화: 각 픽셀의 값에서 채널별 평균을 빼고, 채널별 표준편차로 나누어줍니다.
# 이 과정은 데이터의 평균을 0, 표준편차를 1로 맞추어줌으로써, 데이터를 정규화합니다. 이렇게 하면 모델이 더 빠르고 효율적으로 학습할 수 있습니다.
x_train_full = (x_train_full - x_mean) / x_std
x_test = (x_test - x_mean) / x_std

x_train, x_val, y_train, y_val = train_test_split(x_train_full, y_train_full,test_size = 0.2)

print(x_train.shape)
print(y_train.shape)

print(x_val.shape)
print(y_val.shape)

print(x_test.shape)
print(y_test.shape)

(40000, 32, 32, 3)
(40000, 1)
(10000, 32, 32, 3)
(10000, 1)
(10000, 32, 32, 3)
(10000, 1)

모델 구성 및 학습

def model_build():
    input = Input(shape=(32,32,3))

    output = Conv2D(filters=32, kernel_size=3, padding='same', activation='relu')(input)
    output = BatchNormalization()(output)
    output = MaxPool2D(pool_size=2, strides=2, padding='same')(output)
    output = Dropout(0.3)(output)  # Dropout 추가

    output = Conv2D(filters=64, kernel_size=3, padding='same', activation='relu')(output)
    output = BatchNormalization()(output)
    output = MaxPool2D(pool_size=2, strides=2, padding='same')(output)
    output = Dropout(0.3)(output)  # Dropout 추가

    output = Conv2D(filters=128, kernel_size=3, padding='same', activation='relu')(output)
    output = BatchNormalization()(output)
    output = MaxPool2D(pool_size=2, strides=2, padding='same')(output)
    output = Dropout(0.3)(output)  # Dropout 추가

    output = Flatten()(output)
    output = Dense(256, activation='relu')(output)
    output = Dense(128, activation='relu')(output)
    output = Dense(10, activation='softmax')(output)

    model = Model(inputs=input, outputs=output)

    model.compile(optimizer=Adam(learning_rate=1e-4),
                  loss='sparse_categorical_crossentropy',
                  metrics=['accuracy'])
    return model

model = model_build()
model.summary()

Model: "functional_2"

┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━┓
┃ Layer (type)                         ┃ Output Shape                ┃         Param # ┃
┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━┩
│ input_layer_3 (InputLayer)           │ (None, 32, 32, 3)           │               0 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv2d_7 (Conv2D)                    │ (None, 32, 32, 32)          │             896 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ batch_normalization_4                │ (None, 32, 32, 32)          │             128 │
│ (BatchNormalization)                 │                             │                 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ max_pooling2d_5 (MaxPooling2D)       │ (None, 16, 16, 32)          │               0 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ dropout_2 (Dropout)                  │ (None, 16, 16, 32)          │               0 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv2d_8 (Conv2D)                    │ (None, 16, 16, 64)          │          18,496 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ batch_normalization_5                │ (None, 16, 16, 64)          │             256 │
│ (BatchNormalization)                 │                             │                 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ max_pooling2d_6 (MaxPooling2D)       │ (None, 8, 8, 64)            │               0 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ dropout_3 (Dropout)                  │ (None, 8, 8, 64)            │               0 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv2d_9 (Conv2D)                    │ (None, 8, 8, 128)           │          73,856 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ batch_normalization_6                │ (None, 8, 8, 128)           │             512 │
│ (BatchNormalization)                 │                             │                 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ max_pooling2d_7 (MaxPooling2D)       │ (None, 4, 4, 128)           │               0 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ dropout_4 (Dropout)                  │ (None, 4, 4, 128)           │               0 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ flatten_2 (Flatten)                  │ (None, 2048)                │               0 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ dense_6 (Dense)                      │ (None, 256)                 │         524,544 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ dense_7 (Dense)                      │ (None, 128)                 │          32,896 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ dense_8 (Dense)                      │ (None, 10)                  │           1,290 │
└──────────────────────────────────────┴─────────────────────────────┴─────────────────┘

 Total params: 652,874 (2.49 MB)

 Trainable params: 652,426 (2.49 MB)

 Non-trainable params: 448 (1.75 KB)

history = model.fit(x_train, y_train,
                    epochs=30,
                    batch_size=256,
                    validation_data=(x_val, y_val),
                    verbose=1)

Epoch 1/30
157/157 ━━━━━━━━━━━━━━━━━━━━ 14s 45ms/step - accuracy: 0.2141 - loss: 2.3805 - val_accuracy: 0.1080 - val_loss: 2.6461
Epoch 2/30
157/157 ━━━━━━━━━━━━━━━━━━━━ 2s 12ms/step - accuracy: 0.3799 - loss: 1.7169 - val_accuracy: 0.2475 - val_loss: 2.1843
Epoch 3/30
157/157 ━━━━━━━━━━━━━━━━━━━━ 2s 13ms/step - accuracy: 0.4375 - loss: 1.5589 - val_accuracy: 0.3796 - val_loss: 1.7988
Epoch 4/30
157/157 ━━━━━━━━━━━━━━━━━━━━ 2s 15ms/step - accuracy: 0.4722 - loss: 1.4586 - val_accuracy: 0.4345 - val_loss: 1.6436
Epoch 5/30
157/157 ━━━━━━━━━━━━━━━━━━━━ 2s 12ms/step - accuracy: 0.5085 - loss: 1.3641 - val_accuracy: 0.4518 - val_loss: 1.6275
Epoch 6/30
157/157 ━━━━━━━━━━━━━━━━━━━━ 3s 14ms/step - accuracy: 0.5273 - loss: 1.3022 - val_accuracy: 0.4682 - val_loss: 1.5677
Epoch 7/30
157/157 ━━━━━━━━━━━━━━━━━━━━ 2s 12ms/step - accuracy: 0.5494 - loss: 1.2620 - val_accuracy: 0.4836 - val_loss: 1.5374
Epoch 8/30
157/157 ━━━━━━━━━━━━━━━━━━━━ 2s 12ms/step - accuracy: 0.5694 - loss: 1.2036 - val_accuracy: 0.4937 - val_loss: 1.5278
Epoch 9/30
157/157 ━━━━━━━━━━━━━━━━━━━━ 3s 14ms/step - accuracy: 0.5831 - loss: 1.1606 - val_accuracy: 0.5038 - val_loss: 1.5092
Epoch 10/30
157/157 ━━━━━━━━━━━━━━━━━━━━ 2s 12ms/step - accuracy: 0.5991 - loss: 1.1246 - val_accuracy: 0.5139 - val_loss: 1.4902
Epoch 11/30
157/157 ━━━━━━━━━━━━━━━━━━━━ 2s 12ms/step - accuracy: 0.6068 - loss: 1.0984 - val_accuracy: 0.5207 - val_loss: 1.4868
Epoch 12/30
157/157 ━━━━━━━━━━━━━━━━━━━━ 3s 12ms/step - accuracy: 0.6163 - loss: 1.0636 - val_accuracy: 0.5354 - val_loss: 1.4020
Epoch 13/30
157/157 ━━━━━━━━━━━━━━━━━━━━ 3s 13ms/step - accuracy: 0.6294 - loss: 1.0313 - val_accuracy: 0.5522 - val_loss: 1.3588
Epoch 14/30
157/157 ━━━━━━━━━━━━━━━━━━━━ 3s 14ms/step - accuracy: 0.6372 - loss: 1.0137 - val_accuracy: 0.5594 - val_loss: 1.3492
Epoch 15/30
157/157 ━━━━━━━━━━━━━━━━━━━━ 2s 12ms/step - accuracy: 0.6482 - loss: 0.9896 - val_accuracy: 0.5594 - val_loss: 1.3671
Epoch 16/30
157/157 ━━━━━━━━━━━━━━━━━━━━ 2s 12ms/step - accuracy: 0.6594 - loss: 0.9630 - val_accuracy: 0.5738 - val_loss: 1.2931
Epoch 17/30
157/157 ━━━━━━━━━━━━━━━━━━━━ 3s 12ms/step - accuracy: 0.6688 - loss: 0.9328 - val_accuracy: 0.5773 - val_loss: 1.2941
Epoch 18/30
157/157 ━━━━━━━━━━━━━━━━━━━━ 3s 12ms/step - accuracy: 0.6717 - loss: 0.9184 - val_accuracy: 0.5790 - val_loss: 1.2898
Epoch 19/30
157/157 ━━━━━━━━━━━━━━━━━━━━ 3s 13ms/step - accuracy: 0.6817 - loss: 0.8892 - val_accuracy: 0.5928 - val_loss: 1.2357
Epoch 20/30
157/157 ━━━━━━━━━━━━━━━━━━━━ 2s 14ms/step - accuracy: 0.6863 - loss: 0.8761 - val_accuracy: 0.6040 - val_loss: 1.2148
Epoch 21/30
157/157 ━━━━━━━━━━━━━━━━━━━━ 2s 14ms/step - accuracy: 0.6956 - loss: 0.8556 - val_accuracy: 0.6048 - val_loss: 1.1849
Epoch 22/30
157/157 ━━━━━━━━━━━━━━━━━━━━ 2s 12ms/step - accuracy: 0.7016 - loss: 0.8328 - val_accuracy: 0.6123 - val_loss: 1.1645
Epoch 23/30
157/157 ━━━━━━━━━━━━━━━━━━━━ 2s 12ms/step - accuracy: 0.7058 - loss: 0.8243 - val_accuracy: 0.6244 - val_loss: 1.1196
Epoch 24/30
157/157 ━━━━━━━━━━━━━━━━━━━━ 2s 12ms/step - accuracy: 0.7149 - loss: 0.8032 - val_accuracy: 0.6439 - val_loss: 1.0559
Epoch 25/30
157/157 ━━━━━━━━━━━━━━━━━━━━ 2s 12ms/step - accuracy: 0.7195 - loss: 0.7888 - val_accuracy: 0.6500 - val_loss: 1.0487
Epoch 26/30
157/157 ━━━━━━━━━━━━━━━━━━━━ 2s 14ms/step - accuracy: 0.7284 - loss: 0.7690 - val_accuracy: 0.6487 - val_loss: 1.0579
Epoch 27/30
157/157 ━━━━━━━━━━━━━━━━━━━━ 2s 12ms/step - accuracy: 0.7336 - loss: 0.7528 - val_accuracy: 0.6521 - val_loss: 1.0606
Epoch 28/30
157/157 ━━━━━━━━━━━━━━━━━━━━ 3s 12ms/step - accuracy: 0.7393 - loss: 0.7347 - val_accuracy: 0.6640 - val_loss: 1.0194
Epoch 29/30
157/157 ━━━━━━━━━━━━━━━━━━━━ 2s 12ms/step - accuracy: 0.7464 - loss: 0.7170 - val_accuracy: 0.6682 - val_loss: 1.0068
Epoch 30/30
157/157 ━━━━━━━━━━━━━━━━━━━━ 3s 12ms/step - accuracy: 0.7474 - loss: 0.7082 - val_accuracy: 0.6692 - val_loss: 1.0084

plt.figure(figsize=(12,4))
plt.subplot(1,2,1)
plt.plot(history.history['loss'], 'b--', label='loss')
plt.plot(history.history['val_loss'],'r:',label='val_loss')
plt.xlabel('Epochs')
plt.ylabel('Loss')
plt.grid()
plt.legend()

plt.subplot(1,2,2)
plt.plot(history.history['accuracy'], 'b--', label='acc')
plt.plot(history.history['val_accuracy'],'r:',label='val_acc')
plt.xlabel('Epochs')
plt.ylabel('accuracy')
plt.grid()
plt.legend()
plt.show()

CNN 모델의 발전

• 1998: LeNet – Gradient-based Learning Applied to Document Recognition
• 2012: AlexNet – ImageNet Classification with Deep Convolutional Neural Network
• 2014: VggNet – Very Deep Convolutional Networks for Large-Scale Image Recognition
• 2014: GooLeNet – Going Deeper with Convolutions
• 2014: SppNet – Spatial Pyramid Pooling in Deep Convolutional Networks for Visual Recognition
• 2015: ResNet – Deep Residual Learning for Image Recognition
• 2016: Xception – Xception: Deep Learning with Depthwise Separable Convolutions
• 2017: MobileNet – MobileNets: Efficient Convolutional Neural Networks for Mobile Vision Application
• 2017: DenseNet – Densely Connected Convolutional Networks
• 2017: SeNet – Squeeze and Excitation Networks
• 2017: ShuffleNet – ShuffleNet: An Extremely Efficient Convolutional Neural Network for Mobile Devices
• 2018: NasNet – Learning Transferable Architectures for Scalable Image Recognition
• 2018: Bag of Tricks – Bag of Tricks for Image Classification with Convolutional Neural Networks
• 2019: EfficientNet – EfficientNet: Rethinking Model Scaling for Convolutional Neural Networks

VGGNet(Visual Geometry Group Net)

• 2014년 ILSVRC에서 2등 차지 (상위-5 오류율: 7.32%), 이 후의 수많은 연구에 영향을 미침

• ImageNet에서 훈련이 끝난 후 얻게된 매개변수 값 로딩
• 네트워크를 다시 처음부터 학습하고자 한다면 weights=None으로 설정, 케라스에서 무작위로 가중치를 설정함
• include_top=False: VGG의 밀집 계층을 제외한다는 뜻
• 해당 네트워크의 출력은 합성곱/최대-풀링 블록의 특징맵이 됨
• pooling: 특징맵을 반환하기 전에 적용할 선택적인 연산을 지정

from keras.preprocessing import image
from keras.applications.vgg19 import VGG19, preprocess_input, decode_predictions

vggnet = VGG19(
    include_top=True,         # 최상위(fully connected) 분류 레이어를 포함할지 여부, True면 ImageNet 클래스 분류가 가능
    weights='imagenet',       # 사전 학습된 ImageNet 가중치 사용
    input_tensor=None,        # 입력 텐서를 지정할 경우, 기본값 None
    input_shape=None,         # 입력 이미지의 크기를 지정하지 않으면 기본값 사용 (224x224x3)
    pooling=None,             # 완전 연결 레이어 대신 특정 pooling을 할지 설정 가능 (None이면 기본 사용)
    classes=1000              # ImageNet의 클래스 개수 (1,000개)
    )
vggnet.summary()

Downloading data from https://storage.googleapis.com/tensorflow/keras-applications/vgg19/vgg19_weights_tf_dim_ordering_tf_kernels.h5
574710816/574710816 ━━━━━━━━━━━━━━━━━━━━ 12s 0us/step

Model: "vgg19"

┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━┓
┃ Layer (type)                         ┃ Output Shape                ┃         Param # ┃
┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━┩
│ input_layer_4 (InputLayer)           │ (None, 224, 224, 3)         │               0 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ block1_conv1 (Conv2D)                │ (None, 224, 224, 64)        │           1,792 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ block1_conv2 (Conv2D)                │ (None, 224, 224, 64)        │          36,928 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ block1_pool (MaxPooling2D)           │ (None, 112, 112, 64)        │               0 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ block2_conv1 (Conv2D)                │ (None, 112, 112, 128)       │          73,856 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ block2_conv2 (Conv2D)                │ (None, 112, 112, 128)       │         147,584 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ block2_pool (MaxPooling2D)           │ (None, 56, 56, 128)         │               0 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ block3_conv1 (Conv2D)                │ (None, 56, 56, 256)         │         295,168 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ block3_conv2 (Conv2D)                │ (None, 56, 56, 256)         │         590,080 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ block3_conv3 (Conv2D)                │ (None, 56, 56, 256)         │         590,080 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ block3_conv4 (Conv2D)                │ (None, 56, 56, 256)         │         590,080 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ block3_pool (MaxPooling2D)           │ (None, 28, 28, 256)         │               0 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ block4_conv1 (Conv2D)                │ (None, 28, 28, 512)         │       1,180,160 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ block4_conv2 (Conv2D)                │ (None, 28, 28, 512)         │       2,359,808 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ block4_conv3 (Conv2D)                │ (None, 28, 28, 512)         │       2,359,808 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ block4_conv4 (Conv2D)                │ (None, 28, 28, 512)         │       2,359,808 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ block4_pool (MaxPooling2D)           │ (None, 14, 14, 512)         │               0 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ block5_conv1 (Conv2D)                │ (None, 14, 14, 512)         │       2,359,808 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ block5_conv2 (Conv2D)                │ (None, 14, 14, 512)         │       2,359,808 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ block5_conv3 (Conv2D)                │ (None, 14, 14, 512)         │       2,359,808 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ block5_conv4 (Conv2D)                │ (None, 14, 14, 512)         │       2,359,808 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ block5_pool (MaxPooling2D)           │ (None, 7, 7, 512)           │               0 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ flatten (Flatten)                    │ (None, 25088)               │               0 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ fc1 (Dense)                          │ (None, 4096)                │     102,764,544 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ fc2 (Dense)                          │ (None, 4096)                │      16,781,312 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ predictions (Dense)                  │ (None, 1000)                │       4,097,000 │
└──────────────────────────────────────┴─────────────────────────────┴─────────────────┘

 Total params: 143,667,240 (548.05 MB)

 Trainable params: 143,667,240 (548.05 MB)

 Non-trainable params: 0 (0.00 B)

• dog.jpg (https://www.publicdomainpictures.net/pictures/250000/nahled/dog-beagle-portrait.jpg)

!wget -O dog.jpg https://www.publicdomainpictures.net/pictures/250000/nahled/dog-beagle-portrait.jpg

--2024-11-07 08:18:31--  https://www.publicdomainpictures.net/pictures/250000/nahled/dog-beagle-portrait.jpg
Resolving www.publicdomainpictures.net (www.publicdomainpictures.net)... 104.20.122.60, 104.20.123.60, 172.67.1.236, ...
Connecting to www.publicdomainpictures.net (www.publicdomainpictures.net)|104.20.122.60|:443... connected.
HTTP request sent, awaiting response... 200 OK
Length: 88498 (86K) [image/jpeg]
Saving to: ‘dog.jpg’

dog.jpg             100%[===================>]  86.42K  --.-KB/s    in 0.02s   

2024-11-07 08:18:31 (5.28 MB/s) - ‘dog.jpg’ saved [88498/88498]

img = image.load_img('dog.jpg', target_size=(224, 224))
plt.imshow(img)

x = image.img_to_array(img)
x = preprocess_input(np.expand_dims(x,0))

preds = vggnet.predict(x)
print(decode_predictions(preds))

1/1 ━━━━━━━━━━━━━━━━━━━━ 3s 3s/step
Downloading data from https://storage.googleapis.com/download.tensorflow.org/data/imagenet_class_index.json
35363/35363 ━━━━━━━━━━━━━━━━━━━━ 0s 0us/step
[[('n02088364', 'beagle', 0.83840275), ('n02089973', 'English_foxhound', 0.08918254), ('n02089867', 'Walker_hound', 0.0624161), ('n02088238', 'basset', 0.0046146614), ('n02088632', 'bluetick', 0.003374971)]]

GoogLeNet, Inception

• VGGNet을 제치고 같은 해 분류 과제에서 1등을 차지

• 인셉션 블록이라는 개념을 도입하여, 인셉션 네트워크(Inception Network)라고도 불림

• 깊고 넓은 네트워크 구조를 가지면서도 효율적인 연산 구조를 가지고 있음

  

• 특징

  • GoogLeNet은 CNN 모델의 계산량을 최적화하는 데 중점을 둠
  • 초기에는 전형적인 합성곱 계층과 풀링 계층으로 시작하며, 이후에 이 정보는 9개의 인셉션 모듈(Inception Module) 스택을 통과
  • 인셉션 모듈에서는 입력 특징 맵이 서로 다른 기능을 수행하는 4개의 병렬 하위 블록으로 전달. 이 하위 블록들은 서로 다른 커널 크기와 풀링 방식을 사용하여 다양한 특징을 추출하고, 다시 연결하여 다음 계층으로 전달
  • 모든 합성곱 및 풀링 계층에는 'SAME' 패딩과 stride=1 설정이 적용. 활성화 함수로는 ReLU가 사용되어 모델의 비선형성을 부여

• 기여

  • 블록과 병목 구조를 통해 연산량을 효율적으로 관리하고, 네트워크가 더 깊어지면서도 학습에 안정성을 부여할 수 있게 함
  • 병목 계층으로 1x1 합성곱 계층 사용(채널 수를 줄여 연산량 감소)
  • 병목 계층은 중요한 정보만을 추출하고 압축하여 다음 계층으로 전달할 수 있음. 이를 통해 중요한 특징을 유지하면서도 불필요한 정보를 제거하는 효과가 있음
  • 중간 손실(Intermediate Loss)로 네트워크 중간에서 손실을 발생시키고 이를 역전파함으로써 경사 소실 문제 해결
  

• 병목(bottleneck)**은 신경망에서 연산량과 메모리 사용을 줄이기 위해 특정 계층에서 데이터의 차원을 축소하는 기법

from tensorflow.keras.applications.inception_v3 import InceptionV3, preprocess_input, decode_predictions

inception = InceptionV3(include_top=True, weights='imagenet',
                        input_tensor=None, input_shape=None,
                        pooling=None, classes=1000)

Downloading data from https://storage.googleapis.com/tensorflow/keras-applications/inception_v3/inception_v3_weights_tf_dim_ordering_tf_kernels.h5
96112376/96112376 ━━━━━━━━━━━━━━━━━━━━ 0s 0us/step

• fish.jpg (https://upload.wikimedia.org/wikipedia/commons/7/7a/Goldfish_1.jpg)

!wget -O fish.jpg https://upload.wikimedia.org/wikipedia/commons/7/7a/Goldfish_1.jpg

--2024-11-07 08:56:00--  https://upload.wikimedia.org/wikipedia/commons/7/7a/Goldfish_1.jpg
Resolving upload.wikimedia.org (upload.wikimedia.org)... 198.35.26.112, 2620:0:863:ed1a::2:b
Connecting to upload.wikimedia.org (upload.wikimedia.org)|198.35.26.112|:443... connected.
HTTP request sent, awaiting response... 200 OK
Length: 4648040 (4.4M) [image/jpeg]
Saving to: ‘fish.jpg’

fish.jpg            100%[===================>]   4.43M  20.1MB/s    in 0.2s    

2024-11-07 08:56:00 (20.1 MB/s) - ‘fish.jpg’ saved [4648040/4648040]

img = image.load_img('fish.jpg', target_size=(299, 299))
plt.imshow(img)

x = image.img_to_array(img)
x = preprocess_input(np.expand_dims(x,0))

preds = inception.predict(x)
print(decode_predictions(preds))

1/1 ━━━━━━━━━━━━━━━━━━━━ 9s 9s/step
[[('n01443537', 'goldfish', 0.9748253), ('n02701002', 'ambulance', 0.0023263083), ('n02606052', 'rock_beauty', 0.0019094164), ('n02607072', 'anemone_fish', 0.00066422834), ('n09256479', 'coral_reef', 0.00043224308)]]

모델 깊이와 그라디언트 소실(Gradient Vanishing)

[이미지출처] resnet

ResNet(Residual Net)

• 네트워크의 깊이가 깊어질수록 경사가 소실되거나 폭발하는 문제를 해결하고자 함

• 병목 합성곱 계층을 추가하거나 크기가 작은 커널을 사용

• 152개의 훈련가능한 계층을 수직으로 연결하여 구성

• 모든 합성곱과 풀링 계층에서 패딩옵션으로 'SAME', stride=1 사용

• 3x3 합성곱 계층 다음마다 배치 정규화 적용, 1x1 합성곱 계층에는 활성화 함수가 존재하지 않음

  

잔차 학습(Residual Learning)

• 잔차 연결은 일부 레이어를 건너뛰어(Skip Connection) 데이터가 신경망 구조의 후반부에 도달하는 또 다른 경로를 제공함으로써 정보를 보존하고 gradient가 계속 커지거나 작아지는 문제를 해결할 수 있음

• 잔차 학습을 통해 입력과 출력 사이의 변화를 학습하도록 유도하여, 더 깊은 네트워크에서도 효율적인 학습이 가능하게 함.

• 잔차 블록은 지름길 연결을 추가하여 경사를 효과적으로 전달하므로, 기울기 소실 문제를 완화하고 깊은 네트워크에서도 안정적인 학습을 도움.

• ResNet의 이러한 구조 덕분에 초깊은 네트워크에서도 학습이 가능해졌고, 일반화 성능이 뛰어난 모델로 평가됨

  

from tensorflow.keras.applications.resnet50 import ResNet50, preprocess_input, decode_predictions

resnet = ResNet50(include_top=True, weights='imagenet',
                  input_tensor=None, input_shape=None,
                  pooling=None, classes=1000)

Downloading data from https://storage.googleapis.com/tensorflow/keras-applications/resnet/resnet50_weights_tf_dim_ordering_tf_kernels.h5
102967424/102967424 ━━━━━━━━━━━━━━━━━━━━ 1s 0us/step

• bee.jpg (https://upload.wikimedia.org/wikipedia/commons/4/4d/Apis_mellifera_Western_honey_bee.jpg)

!wget -O bee.jpg https://upload.wikimedia.org/wikipedia/commons/4/4d/Apis_mellifera_Western_honey_bee.jpg

--2024-11-07 09:26:11--  https://upload.wikimedia.org/wikipedia/commons/4/4d/Apis_mellifera_Western_honey_bee.jpg
Resolving upload.wikimedia.org (upload.wikimedia.org)... 198.35.26.112, 2620:0:863:ed1a::2:b
Connecting to upload.wikimedia.org (upload.wikimedia.org)|198.35.26.112|:443... connected.
HTTP request sent, awaiting response... 200 OK
Length: 2421052 (2.3M) [image/jpeg]
Saving to: ‘bee.jpg’

bee.jpg             100%[===================>]   2.31M  --.-KB/s    in 0.1s    

2024-11-07 09:26:11 (16.0 MB/s) - ‘bee.jpg’ saved [2421052/2421052]

img = image.load_img('bee.jpg', target_size=(224, 224))
plt.imshow(img)

x = image.img_to_array(img)
x = preprocess_input(np.expand_dims(x,0))

preds = resnet.predict(x)
print(decode_predictions(preds))

1/1 ━━━━━━━━━━━━━━━━━━━━ 4s 4s/step
[[('n02206856', 'bee', 0.9990979), ('n03530642', 'honeycomb', 0.00056267227), ('n02190166', 'fly', 0.00014306529), ('n02727426', 'apiary', 0.00010191327), ('n02219486', 'ant', 5.741178e-05)]]

Xception

• Inception module을 이용하여 depthwise convolution 적용

핵심 내용

• inception과 ResNet의 장점을 결합한 모델
• 일반적인 CNN 모델은 RGB 이미지를 입력으로 사용하는 경우, R, G, B 채널 전체에 대해 필터를 적용하여 각 필터가 모든 채널을 종합적으로 고려해 특징을 추출함
• Xception은 각 채널에 대해 개별적으로 합성곱 연산을 수행하는 깊이별 합성곱 (depthwise convolution)과, 그 결과를 다시 결합하는 점별 합성곱 (pointwise convolution)을 사용하여 계산량을 크게 줄일 수 있으며, 일반적인 합성곱보다 더 복잡한 패턴을 학습하는 데 유리한 장점을 가짐
• ResNet의 아이디어를 확장해서 skip connection을 도입해 학습을 안정화하고 정보 손실을 줄임

from tensorflow.keras.applications.mobilenet import MobileNet, preprocess_input, decode_predictions

mobilenet = MobileNet(include_top=True, weights='imagenet',
                      input_tensor=None, input_shape=None,
                      pooling=None, classes=1000)
mobilenet.summary()

Downloading data from https://storage.googleapis.com/tensorflow/keras-applications/mobilenet/mobilenet_1_0_224_tf.h5
17225924/17225924 ━━━━━━━━━━━━━━━━━━━━ 0s 0us/step

Model: "mobilenet_1.00_224"

┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━┓
┃ Layer (type)                         ┃ Output Shape                ┃         Param # ┃
┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━┩
│ input_layer_9 (InputLayer)           │ (None, 224, 224, 3)         │               0 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv1 (Conv2D)                       │ (None, 112, 112, 32)        │             864 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv1_bn (BatchNormalization)        │ (None, 112, 112, 32)        │             128 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv1_relu (ReLU)                    │ (None, 112, 112, 32)        │               0 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv_dw_1 (DepthwiseConv2D)          │ (None, 112, 112, 32)        │             288 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv_dw_1_bn (BatchNormalization)    │ (None, 112, 112, 32)        │             128 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv_dw_1_relu (ReLU)                │ (None, 112, 112, 32)        │               0 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv_pw_1 (Conv2D)                   │ (None, 112, 112, 64)        │           2,048 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv_pw_1_bn (BatchNormalization)    │ (None, 112, 112, 64)        │             256 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv_pw_1_relu (ReLU)                │ (None, 112, 112, 64)        │               0 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv_pad_2 (ZeroPadding2D)           │ (None, 113, 113, 64)        │               0 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv_dw_2 (DepthwiseConv2D)          │ (None, 56, 56, 64)          │             576 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv_dw_2_bn (BatchNormalization)    │ (None, 56, 56, 64)          │             256 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv_dw_2_relu (ReLU)                │ (None, 56, 56, 64)          │               0 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv_pw_2 (Conv2D)                   │ (None, 56, 56, 128)         │           8,192 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv_pw_2_bn (BatchNormalization)    │ (None, 56, 56, 128)         │             512 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv_pw_2_relu (ReLU)                │ (None, 56, 56, 128)         │               0 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv_dw_3 (DepthwiseConv2D)          │ (None, 56, 56, 128)         │           1,152 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv_dw_3_bn (BatchNormalization)    │ (None, 56, 56, 128)         │             512 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv_dw_3_relu (ReLU)                │ (None, 56, 56, 128)         │               0 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv_pw_3 (Conv2D)                   │ (None, 56, 56, 128)         │          16,384 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv_pw_3_bn (BatchNormalization)    │ (None, 56, 56, 128)         │             512 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv_pw_3_relu (ReLU)                │ (None, 56, 56, 128)         │               0 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv_pad_4 (ZeroPadding2D)           │ (None, 57, 57, 128)         │               0 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv_dw_4 (DepthwiseConv2D)          │ (None, 28, 28, 128)         │           1,152 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv_dw_4_bn (BatchNormalization)    │ (None, 28, 28, 128)         │             512 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv_dw_4_relu (ReLU)                │ (None, 28, 28, 128)         │               0 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv_pw_4 (Conv2D)                   │ (None, 28, 28, 256)         │          32,768 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv_pw_4_bn (BatchNormalization)    │ (None, 28, 28, 256)         │           1,024 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv_pw_4_relu (ReLU)                │ (None, 28, 28, 256)         │               0 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv_dw_5 (DepthwiseConv2D)          │ (None, 28, 28, 256)         │           2,304 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv_dw_5_bn (BatchNormalization)    │ (None, 28, 28, 256)         │           1,024 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv_dw_5_relu (ReLU)                │ (None, 28, 28, 256)         │               0 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv_pw_5 (Conv2D)                   │ (None, 28, 28, 256)         │          65,536 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv_pw_5_bn (BatchNormalization)    │ (None, 28, 28, 256)         │           1,024 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv_pw_5_relu (ReLU)                │ (None, 28, 28, 256)         │               0 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv_pad_6 (ZeroPadding2D)           │ (None, 29, 29, 256)         │               0 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv_dw_6 (DepthwiseConv2D)          │ (None, 14, 14, 256)         │           2,304 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv_dw_6_bn (BatchNormalization)    │ (None, 14, 14, 256)         │           1,024 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv_dw_6_relu (ReLU)                │ (None, 14, 14, 256)         │               0 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv_pw_6 (Conv2D)                   │ (None, 14, 14, 512)         │         131,072 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv_pw_6_bn (BatchNormalization)    │ (None, 14, 14, 512)         │           2,048 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv_pw_6_relu (ReLU)                │ (None, 14, 14, 512)         │               0 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv_dw_7 (DepthwiseConv2D)          │ (None, 14, 14, 512)         │           4,608 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv_dw_7_bn (BatchNormalization)    │ (None, 14, 14, 512)         │           2,048 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv_dw_7_relu (ReLU)                │ (None, 14, 14, 512)         │               0 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv_pw_7 (Conv2D)                   │ (None, 14, 14, 512)         │         262,144 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv_pw_7_bn (BatchNormalization)    │ (None, 14, 14, 512)         │           2,048 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv_pw_7_relu (ReLU)                │ (None, 14, 14, 512)         │               0 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv_dw_8 (DepthwiseConv2D)          │ (None, 14, 14, 512)         │           4,608 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv_dw_8_bn (BatchNormalization)    │ (None, 14, 14, 512)         │           2,048 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv_dw_8_relu (ReLU)                │ (None, 14, 14, 512)         │               0 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv_pw_8 (Conv2D)                   │ (None, 14, 14, 512)         │         262,144 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv_pw_8_bn (BatchNormalization)    │ (None, 14, 14, 512)         │           2,048 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv_pw_8_relu (ReLU)                │ (None, 14, 14, 512)         │               0 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv_dw_9 (DepthwiseConv2D)          │ (None, 14, 14, 512)         │           4,608 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv_dw_9_bn (BatchNormalization)    │ (None, 14, 14, 512)         │           2,048 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv_dw_9_relu (ReLU)                │ (None, 14, 14, 512)         │               0 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv_pw_9 (Conv2D)                   │ (None, 14, 14, 512)         │         262,144 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv_pw_9_bn (BatchNormalization)    │ (None, 14, 14, 512)         │           2,048 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv_pw_9_relu (ReLU)                │ (None, 14, 14, 512)         │               0 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv_dw_10 (DepthwiseConv2D)         │ (None, 14, 14, 512)         │           4,608 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv_dw_10_bn (BatchNormalization)   │ (None, 14, 14, 512)         │           2,048 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv_dw_10_relu (ReLU)               │ (None, 14, 14, 512)         │               0 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv_pw_10 (Conv2D)                  │ (None, 14, 14, 512)         │         262,144 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv_pw_10_bn (BatchNormalization)   │ (None, 14, 14, 512)         │           2,048 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv_pw_10_relu (ReLU)               │ (None, 14, 14, 512)         │               0 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv_dw_11 (DepthwiseConv2D)         │ (None, 14, 14, 512)         │           4,608 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv_dw_11_bn (BatchNormalization)   │ (None, 14, 14, 512)         │           2,048 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv_dw_11_relu (ReLU)               │ (None, 14, 14, 512)         │               0 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv_pw_11 (Conv2D)                  │ (None, 14, 14, 512)         │         262,144 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv_pw_11_bn (BatchNormalization)   │ (None, 14, 14, 512)         │           2,048 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv_pw_11_relu (ReLU)               │ (None, 14, 14, 512)         │               0 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv_pad_12 (ZeroPadding2D)          │ (None, 15, 15, 512)         │               0 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv_dw_12 (DepthwiseConv2D)         │ (None, 7, 7, 512)           │           4,608 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv_dw_12_bn (BatchNormalization)   │ (None, 7, 7, 512)           │           2,048 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv_dw_12_relu (ReLU)               │ (None, 7, 7, 512)           │               0 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv_pw_12 (Conv2D)                  │ (None, 7, 7, 1024)          │         524,288 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv_pw_12_bn (BatchNormalization)   │ (None, 7, 7, 1024)          │           4,096 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv_pw_12_relu (ReLU)               │ (None, 7, 7, 1024)          │               0 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv_dw_13 (DepthwiseConv2D)         │ (None, 7, 7, 1024)          │           9,216 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv_dw_13_bn (BatchNormalization)   │ (None, 7, 7, 1024)          │           4,096 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv_dw_13_relu (ReLU)               │ (None, 7, 7, 1024)          │               0 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv_pw_13 (Conv2D)                  │ (None, 7, 7, 1024)          │       1,048,576 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv_pw_13_bn (BatchNormalization)   │ (None, 7, 7, 1024)          │           4,096 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv_pw_13_relu (ReLU)               │ (None, 7, 7, 1024)          │               0 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ global_average_pooling2d             │ (None, 1, 1, 1024)          │               0 │
│ (GlobalAveragePooling2D)             │                             │                 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ dropout (Dropout)                    │ (None, 1, 1, 1024)          │               0 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv_preds (Conv2D)                  │ (None, 1, 1, 1000)          │       1,025,000 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ reshape_2 (Reshape)                  │ (None, 1000)                │               0 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ predictions (Activation)             │ (None, 1000)                │               0 │
└──────────────────────────────────────┴─────────────────────────────┴─────────────────┘

 Total params: 4,253,864 (16.23 MB)

 Trainable params: 4,231,976 (16.14 MB)

 Non-trainable params: 21,888 (85.50 KB)

• crane.jpg (https://p1.pxfuel.com/preview/42/50/534/europe-channel-crane-harbour-crane-harbour-cranes-cranes-transport.jpg)

!wget -O crane.jpg https://p1.pxfuel.com/preview/42/50/534/europe-channel-crane-harbour-crane-harbour-cranes-cranes-transport.jpg

--2024-11-07 09:44:54--  https://p1.pxfuel.com/preview/42/50/534/europe-channel-crane-harbour-crane-harbour-cranes-cranes-transport.jpg
Resolving p1.pxfuel.com (p1.pxfuel.com)... 104.21.12.22, 172.67.151.78, 2606:4700:3037::ac43:974e, ...
Connecting to p1.pxfuel.com (p1.pxfuel.com)|104.21.12.22|:443... connected.
HTTP request sent, awaiting response... 200 OK
Length: 86911 (85K) [image/jpeg]
Saving to: ‘crane.jpg’

crane.jpg           100%[===================>]  84.87K  --.-KB/s    in 0.01s   

2024-11-07 09:44:54 (6.00 MB/s) - ‘crane.jpg’ saved [86911/86911]

img = image.load_img('crane.jpg', target_size=(224, 224))
plt.imshow(img)

x = image.img_to_array(img)
x = preprocess_input(np.expand_dims(x,0))

preds = mobilenet.predict(x)
print(decode_predictions(preds))

WARNING:tensorflow:5 out of the last 6 calls to <function TensorFlowTrainer.make_predict_function.<locals>.one_step_on_data_distributed at 0x7d034f6fdcf0> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has reduce_retracing=True option that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/guide/function#controlling_retracing and https://www.tensorflow.org/api_docs/python/tf/function for  more details.


1/1 ━━━━━━━━━━━━━━━━━━━━ 3s 3s/step
[[('n03126707', 'crane', 0.96338284), ('n03216828', 'dock', 0.027054528), ('n03240683', 'drilling_platform', 0.0047102487), ('n03344393', 'fireboat', 0.0022202074), ('n03532672', 'hook', 0.0005047548)]]

DenseNet

• 각 층은 모든 이전 층으로 부터 출력을 입력으로 받음(밀집 블록(dense block))
• 이러한 조밀 연결은 특징 맵을 재활용하며 네트워크 깊이가 깊어지더라도 이전 층에서 추출된 정보를 유지해 효율적인 학습을 가능하게 함
• 특징지도의 크기를 줄이기 위해 풀링 연산 적용 필요
• 각 층이 이전 모든 층의 출력을 활용할 수 있어 불필요한 특성 학습을 줄여 고유한 필터를 학습하지 않아도 되기 때문에 네트워크의 파라미터 수가 줄어듬.
• 위 특징으로 인해 메모리와 계산량을 줄이고, 경량 모델을 만들 수 있음.
• 밀집 블록(dense block)과 전이층(transition layer)으로 구성
• 전이층 : 1x1 컨볼루션과 평균값 풀링(APool)으로 구성 -> 특징 맵의 크기와 채널 수를 줄임

from tensorflow.keras.applications.densenet import DenseNet201, preprocess_input, decode_predictions

densenet = DenseNet201(include_top=True, weights='imagenet',
                  input_tensor=None, input_shape=None,
                  pooling=None, classes=1000)

Downloading data from https://storage.googleapis.com/tensorflow/keras-applications/densenet/densenet201_weights_tf_dim_ordering_tf_kernels.h5
82524592/82524592 ━━━━━━━━━━━━━━━━━━━━ 1s 0us/step

• zebra.jpg (https://upload.wikimedia.org/wikipedia/commons/f/f0/Zebra_standing_alone_crop.jpg)

!wget -O zebra.jpg https://upload.wikimedia.org/wikipedia/commons/f/f0/Zebra_standing_alone_crop.jpg

--2024-11-07 10:49:10--  https://upload.wikimedia.org/wikipedia/commons/f/f0/Zebra_standing_alone_crop.jpg
Resolving upload.wikimedia.org (upload.wikimedia.org)... 198.35.26.112, 2620:0:863:ed1a::2:b
Connecting to upload.wikimedia.org (upload.wikimedia.org)|198.35.26.112|:443... connected.
HTTP request sent, awaiting response... 200 OK
Length: 188036 (184K) [image/jpeg]
Saving to: ‘zebra.jpg’


zebra.jpg             0%[                    ]       0  --.-KB/s               
zebra.jpg           100%[===================>] 183.63K  --.-KB/s    in 0.05s   

2024-11-07 10:49:11 (3.35 MB/s) - ‘zebra.jpg’ saved [188036/188036]

img = image.load_img('zebra.jpg', target_size=(224, 224))
plt.imshow(img)

x = image.img_to_array(img)
x = preprocess_input(np.expand_dims(x,0))

preds = densenet.predict(x)
print(decode_predictions(preds))

WARNING:tensorflow:6 out of the last 7 calls to <function TensorFlowTrainer.make_predict_function.<locals>.one_step_on_data_distributed at 0x7d034faa2c20> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has reduce_retracing=True option that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/guide/function#controlling_retracing and https://www.tensorflow.org/api_docs/python/tf/function for  more details.


1/1 ━━━━━━━━━━━━━━━━━━━━ 18s 18s/step
[[('n02391049', 'zebra', 0.9299189), ('n01518878', 'ostrich', 0.020074163), ('n02423022', 'gazelle', 0.012079946), ('n02397096', 'warthog', 0.00449013), ('n02422106', 'hartebeest', 0.003128522)]]

NasNet

• 강화학습을 활용한 자동화된 아키텍처 탐색(Neural Architecture Search (NAS))으로 최적의 신경망 구조를 효율적으로 설계
• NASNet에서 찾아낸 최적의 구조는 사람의 설계로는 발견하기 어려운 방식으로 조합되어 있어, 기존의 수작업 모델보다 효율적이면서도 성능이 뛰어난 경우가 많음
• 높은 성능과 효율성을 동시에 만족하는 최적의 아키텍처 발견

from tensorflow.keras.applications.nasnet import NASNetLarge, preprocess_input, decode_predictions

nasnet = NASNetLarge(include_top=True, weights='imagenet',
                  input_tensor=None, input_shape=None,
                  pooling=None, classes=1000)

Downloading data from https://storage.googleapis.com/tensorflow/keras-applications/nasnet/NASNet-large.h5
359748576/359748576 ━━━━━━━━━━━━━━━━━━━━ 2s 0us/step

• notebook.jpg (https://cdn.pixabay.com/photo/2016/07/11/03/35/macbook-1508998_1280.jpg)

!wget -O notebook.jpg https://cdn.pixabay.com/photo/2016/07/11/03/35/macbook-1508998_1280.jpg

--2024-11-07 11:01:16--  https://cdn.pixabay.com/photo/2016/07/11/03/35/macbook-1508998_1280.jpg
Resolving cdn.pixabay.com (cdn.pixabay.com)... 172.64.147.160, 104.18.40.96, 2606:4700:4400::ac40:93a0, ...
Connecting to cdn.pixabay.com (cdn.pixabay.com)|172.64.147.160|:443... connected.
HTTP request sent, awaiting response... 200 OK
Length: 270631 (264K) [binary/octet-stream]
Saving to: ‘notebook.jpg’

notebook.jpg        100%[===================>] 264.29K  --.-KB/s    in 0.07s   

2024-11-07 11:01:16 (3.55 MB/s) - ‘notebook.jpg’ saved [270631/270631]

img = image.load_img('notebook.jpg', target_size=(331, 331))
plt.imshow(img)

x = image.img_to_array(img)
x = preprocess_input(np.expand_dims(x,0))

preds = nasnet.predict(x)
print(decode_predictions(preds))

1/1 ━━━━━━━━━━━━━━━━━━━━ 21s 21s/step
[[('n03832673', 'notebook', 0.79398525), ('n03642806', 'laptop', 0.048131146), ('n04264628', 'space_bar', 0.0341737), ('n03085013', 'computer_keyboard', 0.020013861), ('n03777754', 'modem', 0.011280097)]]

EfficientNet

• EfficientNet은 EfficientNet-B0라는 기준 모델을 시작점으로 함. 이 모델은 신경망 아키텍처 검색(NAS)을 통해 찾은 효율적인 구조임
• NAS를 통해 발견된 B0 아키텍처는 이미 효율성과 성능을 극대화한 구조로, 이를 바탕으로 다른 버전(B1~B7)들이 파생됨
• NASNet처럼 각 모델의 모든 세부 구조를 탐색하지 않고, B0 모델을 시작으로 Compound Scaling 공식을 적용해 네트워크의 깊이, 너비, 해상도를 균형 있게 확장함
• Compound Scaling은 깊(레이어수), 너비(채널수/필터수), 해상도(입력이미지크기)를 여러 시도와 탐색을 통해 찾은 비율로 함께 확장해 모델의 성능과 자원 효율성을 동시에 최적화하는 기법임

from tensorflow.keras.applications.efficientnet import EfficientNetB1, preprocess_input, decode_predictions

efficientnet = EfficientNetB1(include_top=True, weights='imagenet',
                  input_tensor=None, input_shape=None,
                  pooling=None, classes=1000)

Downloading data from https://storage.googleapis.com/keras-applications/efficientnetb1.h5
32148312/32148312 ━━━━━━━━━━━━━━━━━━━━ 0s 0us/step

• plane.jpg (https://upload.wikimedia.org/wikipedia/commons/1/12/Plane-in-flight.jpg)

!wget -O plane.jpg https://upload.wikimedia.org/wikipedia/commons/1/12/Plane-in-flight.jpg

--2024-11-07 11:17:00--  https://upload.wikimedia.org/wikipedia/commons/1/12/Plane-in-flight.jpg
Resolving upload.wikimedia.org (upload.wikimedia.org)... 198.35.26.112, 2620:0:863:ed1a::2:b
Connecting to upload.wikimedia.org (upload.wikimedia.org)|198.35.26.112|:443... connected.
HTTP request sent, awaiting response... 200 OK
Length: 487351 (476K) [image/jpeg]
Saving to: ‘plane.jpg’

plane.jpg           100%[===================>] 475.93K  --.-KB/s    in 0.1s    

2024-11-07 11:17:00 (3.75 MB/s) - ‘plane.jpg’ saved [487351/487351]

img = image.load_img('plane.jpg', target_size=(240, 240))
plt.imshow(img)

x = image.img_to_array(img)
x = preprocess_input(np.expand_dims(x,0))

preds = efficientnet.predict(x)
print(decode_predictions(preds))

1/1 ━━━━━━━━━━━━━━━━━━━━ 11s 11s/step
[[('n02690373', 'airliner', 0.7460463), ('n04592741', 'wing', 0.079652555), ('n04552348', 'warplane', 0.05106398), ('n04266014', 'space_shuttle', 0.016655603), ('n01494475', 'hammerhead', 0.00594431)]]

OPENCV 이미지처리

import cv2
import numpy as np
import matplotlib.pyplot as plt
from google.colab import files
from google.colab.patches import cv2_imshow

도형 그리기

• 다양한 도형을 그릴 수 있음

• 도형을 그리는 좌표가 해당 범위를 넘어가면 이미지에 표현되지 않음

img = np.zeros((512,512,3), np.uint8)

plt.imshow(img)
plt.show()

Line 그리기

• cv.line()

  • Parameters

    • img : 그림을 그릴 이미지 파일

    • start : 시작 좌표

    • end : 종료 좌표

    • color : BGR형태의 Color (ex; (255, 0, 0) -> Blue)

    • thickness (int) : 선의 두께. pixel

img = cv2.line(img, (0,0), (511,511), (255,0,0), 5) # 시작, 끝, 컬러(BGR), 두께

plt.imshow(img) # 왜 붉은 색 선일까? -> B에 그렸으나 R로 인식
plt.show()

rectangle 그리기

• cv2.rectangle()

  • Parameters

    • img : 그림을 그릴 이미지

    • start : 시작 좌표

    • end : 종료 좌표

    • color : BGR형태의 Color(ex; (255, 0, 0) -> Blue)

    • thickness (int) : 선의 두께. pixel

img = cv2.rectangle(img, (0,0), (250,350), (0,255,0), 3)

plt.imshow(img)
plt.show()

Circle 그리기

• cv2.circle()

  • Parameters

    • img : 그림을 그릴 이미지

    • center : 원의 중심 좌표(x, y)

    • radian : 반지름

    • color : BGR형태의 Color

    • thickness : 선의 두께, -1 이면 원 안쪽을 채움

img = cv2.circle(img, (447, 63), 63, (0,0,255), -1)

plt.imshow(img)
plt.show()

img = cv2.circle(img, (63,447), 63,  (0,255,255), 2)

plt.imshow(img)
plt.show()

ellipse(타원) 그리기

• cv2.ellipse()

  • Parameters

    • img : image

    • center : 타원의 중심

    • axes : 중심에서 가장 큰 거리와 작은 거리

    • angle : 타원의 기울기 각

    • startAngle : 타원의 시작 각도

    • endAngle : 타원이 끝나는 각도

    • color : 타원의 색

    • thickness : 선 두께. -1이면 안쪽을 채움

# 타원을 이미지에 그리기 (회색 타원)
# 중심 좌표: (255, 255), 축 길이: (100, 50), 회전 각도: 0, 호의 시작각도: 10도, 끝각도: 255도, 채우기: -1
img = cv2.ellipse(img,  (255,255), (100,50), 0,  10, 255,  -1)

plt.imshow(img)
plt.show()

# 타원을 이미지에 그리기 (흰색 타원)
# 중심 좌표: (255, 255), 축 길이: (150, 50), 회전 각도: 45, 호의 시작각도: 0도, 끝각도: 360도, 두께: 2
img = cv2.ellipse(img,  (255,255), (150,50), 45, 0, 360, (255,255,255), 2)

plt.imshow(img)
plt.show()

# 타원을 이미지에 그리기 (파란색 부분 타원)
# 중심 좌표: (255, 255), 축 길이: (150, 10), 회전 각도: 135, 호의 시작각도: 0도, 끝각도: 270도, 두께: 2
img  = cv2.ellipse(img,  (255,255), (150,10), 135, 0, 270, (0,0,255), 2)

plt.imshow(img)
plt.show()

Polygon 그리기

• cv2.polylines()

  • Parameters

    • img : image

    • pts (array) : 연결할 꼭지점 좌표

    • isClosed : 닫힌 도형 여부

    • color : Color

    • thickness : 선 두께

• 이미지에 표현하기 위해 점 좌표를 3차원 행렬로 변환.

  • 변환이전과 이후의 행렬 갯수는 동일해야함.

# 폴리라인(다각형)을 그리기
# 점들의 좌표 정의 (정수형 배열로 변환)
pts = np.array([[10,5], [20,30], [70,20], [50,10]], np.int32)
print(pts.shape)

(4, 2)

# 점들의 형태를 (n, 2, 1)에서 (n, 1, 2)로 변환
pts = pts.reshape((-1,2,1)) # 3차원 행렬로 변환하기 위해
print(pts.shape)
# 폴리라인 그리기, 닫힌 형태(True), 색상: 오렌지, 두께: 5
img = cv2.polylines(img, [pts], True, (0, 155, 255), 5)

(4, 2, 1)

plt.imshow(img)
plt.show()

# 또 다른 다각형 정의 및 폴리라인 그리기
pts2 = np.array([[150,5], [200,30], [100,70], [50,20]], np.int32)
print(pts2.shape)

(4, 2)

# (n, 2, 1) 형태에서 (n, 1, 2)로 변환
pts2 = pts2.reshape((-1,1,2))
print(pts2.shape)
# 폴리라인 그리기, 닫힌 형태(True), 색상: 연한 보라색, 두께: 4
img = cv2.polylines(img, [pts2], True, (172, 200, 255), 4)

(4, 1, 2)

plt.imshow(img)
plt.show()

Text 추가하기

• cv2.putText()

  • Parameters

    • img : image

    • text : 표시할 문자열

    • org : 문자열이 표시될 위치. 문자열의 bottom-left corner 점

    • font : font type. CV2.FONT_XXX

    • fontSacle : Font Size

    • color : fond color

# 텍스트 추가
# 텍스트: 'OpenCV', 좌표: (10, 500), 폰트: SIMPLEX, 크기: 4, 색상: 흰색, 두께: 3
img = cv2.putText(img, 'OpenCV', (10, 500), cv2.FONT_HERSHEY_SIMPLEX, 4, (255,255,255), 3)

plt.imshow(img)
plt.show()

문제 : 별 그리기

img = np.zeros((540,540), np.uint8)
plt.imshow(img, cmap='gray')
plt.show()

정답 :

문제 정답: 별 그리기 (8개의 교차선으로 구성)

img = cv2.line(img, (0, 0), (270, 540), 255, 4) # 왼쪽 위 → 중앙 아래 img = cv2.line(img, (0, 0), (540, 270), 255, 4) # 왼쪽 위 → 중앙 오른쪽 img = cv2.line(img, (540, 0), (0, 270), 255, 4) # 오른쪽 위 → 중앙 왼쪽 img = cv2.line(img, (540, 0), (270, 540), 255, 4) # 오른쪽 위 → 중앙 아래 img = cv2.line(img, (0, 540), (270, 0), 255, 4) # 왼쪽 아래 → 중앙 위 img = cv2.line(img, (0, 540), (540, 270), 255, 4) # 왼쪽 아래 → 중앙 오른쪽 img = cv2.line(img, (540, 540), (0, 270), 255, 4) # 오른쪽 아래 → 중앙 왼쪽 img = cv2.line(img, (540, 540), (270, 0), 255, 4) # 오른쪽 아래 → 중앙 위

이미지 처리 (Image Processing)

• 필요에 따라 적절한 처리

• resize(), flip(), getAffineTransform(), warpAffine() 등 다양한 메서드 존재

• 코드 출처 : https://opencv-python.readthedocs.io/en/latest/index.html

# 이미지 다운로드 주소 : https://upload.wikimedia.org/wikipedia/ko/2/24/Lenna.png
files.upload()
image = cv2.imread('Lenna.png')
print(image.shape)
cv2_imshow(image)

Resize

• cv2.resize()

  • 사이즈가 변하면 pixel사이의 값을 결정을 해야함

  • 보간법(Interpolation method)

    • 사이즈를 줄일 때 : cv2.INTER_AREA

    • 사이즈를 크게 할 때 : cv2.INTER_CUBIC , cv2.INTER_LINEAR

  • Parameters

    • img : Image

    • dsize : Manual Size. 가로, 세로 형태의 tuple(ex; (100,200))

    • fx : 가로 사이즈의 배수. 2배로 크게하려면 2. 반으로 줄이려면 0.5

    • fy : 세로 사이즈의 배수

    • interpolation : 보간법

cv2_imshow(image)

'''
cv2.resize(src, dsize[, dst[, fx[, fy[, interpolation]]]])
여기서 각 인자는 다음을 의미합니다:

src: 크기를 조절하려는 원본 이미지입니다.
dsize: 새로운 이미지의 크기입니다. (width, height) 형식의 튜플로 지정할 수 있습니다.
dst: 선택적으로, 크기를 조절한 이미지를 저장할 곳을 지정합니다. 이 인자를 생략하면 함수가 새로운 이미지를 반환합니다.
fx: 선택적으로 가로 방향 크기의 배율 요인입니다.
fy: 선택적으로 세로 방향 크기의 배율 요인입니다.
interpolation: 선택적으로 크기 조절에 사용할 보간법을 지정합니다. 기본값은 cv2.INTER_LINEAR로, 선형 보간법을 사용합니다.
다른 옵션으로는 cv2.INTER_NEAREST, cv2.INTER_AREA, cv2.INTER_CUBIC, cv2.INTER_LANCZOS4 등이 있습니다.
'''
height, width = image.shape[:2]
print(height, width)

shrink = cv2.resize(image, (0,0), fx=0.5, fy=0.5, interpolation=cv2.INTER_AREA) # 새 이미지의 크기를 직접 지정하지 않은 것
print(shrink.shape)
expand1 = cv2.resize(image, (width*2, height*2), interpolation=cv2.INTER_CUBIC)  # 크기 2배 확대
print(expand1.shape)
expand2 = cv2.resize(image, None, fx=2, fy=2, interpolation=cv2.INTER_CUBIC)  # 크기 2배 확대 (명시적 크기 미지정)
print(expand2.shape)

220 220
(110, 110, 3)
(440, 440, 3)
(440, 440, 3)

cv2_imshow(shrink)  # 축소된 이미지 표시
cv2_imshow(expand1)  # 확대된 이미지 표시 (방식 1)
cv2_imshow(expand2)  # 확대된 이미지 표시 (방식 2)

Translation

• 이미지의 위치를 변경

• cv2.warpAffine()

  • Parameters

    • src : Image

    • M : 변환 행렬

    • dsize (tuple) : output image size(ex; (width=columns, height=rows)

'''
[1, 0, 10], [0, 1, 20]

1: 축 방향의 스케일링 비율을 나타내며, 이 경우 1이므로 x축 방향의 크기 변화가 없음을 의미합니다.
0: y축으로부터 x축으로의 기울기(회전)를 나타냅니다. 0이므로 이 방향으로의 회전이 없음을 의미합니다.
10: x축 방향으로의 이동(변환)을 나타내며, 이 값은 이미지를 오른쪽으로 10 픽셀 이동시킵니다.

0: x축으로부터 y축으로의 기울기(회전)를 나타냅니다. 0이므로 이 방향으로의 회전이 없음을 의미합니다.
1: y축 방향의 스케일링 비율을 나타내며, 이 경우 1이므로 y축 방향의 크기 변화가 없음을 의미합니다.
20: y축 방향으로의 이동(변환)을 나타내며, 이 값은 이미지를 아래로 20 픽셀 이동시킵니다.
'''
# 이미지 이동 (Translation)
rows, cols = image.shape[:2]
M = np.float32([[1, 0, 10], [0, 1, 20]])  # 이동 행렬: x축 10 픽셀, y축 20 픽셀 이동
dst = cv2.warpAffine(image, M, (cols, rows))  # 이동 적용
cv2_imshow(dst)  # 이동된 이미지 표시

Rotate

• 물체를 평면상의 한 점을 중심으로 𝜃 만큼 회전하는 변환

• 양의 각도는 시계반대방향으로 회전

• cv2.getRotationMatrix2D()

  • Parameters

    • center : 이미지의 중심 좌표

    • angle : 회전 각도

    • scale : scale factor

# 이미지 회전
rows, cols, _ = image.shape
M = cv2.getRotationMatrix2D((cols / 2, rows / 2), 45, 1)  # 중심에서 45도 회전
rotated_img = cv2.warpAffine(image, M, (cols, rows))  # 회전 적용
cv2_imshow(rotated_img) # 회전된 이미지 표시

Flip

• 대칭 변환

  • 좌우 대칭 (좌우 반전)

  • 상하 대칭 (상하 반전)

• 입력 영상과 출력 영상의 픽셀이 1:1 매칭이므로 보간법이 필요 없음

• cv2.flip()

  • Parameters

    • src : 입력 영상

    • flipCode : 대칭 방법을 결정하는 flag 인자

      • 양수이면 좌우 대칭

      • 0이면 상하 대칭

      • 음수이면 상하, 좌우 대칭을 모두 실행

result2 = cv2.flip(image, 0)  # 수직 뒤집기
result3 = cv2.flip(image, 1)  # 수평 뒤집기
cv2_imshow(result2)  # 수직 뒤집힌 이미지 표시
cv2_imshow(result3)  # 수평 뒤집힌 이미지 표시

Affine Transformation

• 기하학적 도형의 크기와 각도를 변경할 수 있지만, 원점 간의 상대적인 위치(선의 평행성과 점들 간의 비율)는 보존

• 이동, 확대, Scale, 반전까지 포함된 변환

• cv2.getAffineTransform()

  • Affine 변환을 위해서는 3개의 Match가 되는 점이 있으면 변환행렬을 구할 수 있음

# 원본 이미지의 크기와 채널 정보 가져오기
# rows: 이미지의 높이(픽셀 수), cols: 너비(픽셀 수), ch: 채널 수 (컬러 이미지라서 3)
rows, cols, ch = image.shape

# Affine 변환을 위한 원본 좌표와 이동 좌표 설정
# 원본 좌표: pts1 (Affine 변환 전의 3개 점)
pts1 = np.float32([[100, 50], [200, 50], [100, 100]])
# 이동 좌표: pts2 (Affine 변환 후의 3개 점)
pts2 = np.float32([[100, 150], [200, 100], [100, 200]])

# Affine 변환에서 사용하는 3개의 점 시각화를 위해 원본 이미지에 원 그리기
# 첫 번째 점 (200, 100) 빨간색 점
cv2.circle(image, (200, 100), 10, (255, 0, 0), -1)  # 색상: 빨강 (BGR 형식), 두께: -1 (채우기)
# 두 번째 점 (400, 100) 초록색 점
cv2.circle(image, (400, 100), 10, (0, 255, 0), -1)  # 색상: 초록 (BGR 형식), 두께: -1 (채우기)
# 세 번째 점 (200, 200) 파란색 점
cv2.circle(image, (200, 200), 10, (0, 0, 255), -1)  # 색상: 파랑 (BGR 형식), 두께: -1 (채우기)

# 원본 좌표(pts1)와 이동 좌표(pts2)를 기반으로 Affine 변환 행렬 계산
# M: 2x3 변환 행렬, 이 행렬은 점들의 위치를 기반으로 전체 이미지를 변환하는 데 사용됨
M = cv2.getAffineTransform(pts1, pts2)

# Affine 변환 적용
# cv2.warpAffine(): 이미지를 변환 행렬(M)을 기반으로 변환
# cols, rows: 결과 이미지의 크기 (원본 이미지와 동일하게 설정)
dst = cv2.warpAffine(image, M, (cols, rows))

# 변환된 이미지(dst) 출력
cv2_imshow(dst)  # Google Colab에서 이미지를 표시하는 함수
# 변환된 이미지의 크기 확인
print(dst.shape)  # 변환 후에도 원본 이미지 크기(높이, 너비, 채널)가 유지됨

(220, 220, 3)

# 문제 1: 이미지 크기 조절
# 목표: 주어진 이미지의 크기를 사용자가 지정한 크기로 조절하는 기능을 구현합니다.
# 설명: 이미지를 200x200 크기로 조절해보세요. 다양한 보간법을 적용하며 결과를 비교합니다.

# 이미지 불러오기
img = cv2.imread('Lenna.png')
# 크기 조절

# 이미지 표시
plt.imshow(cv2.cvtColor(resized_img, cv2.COLOR_BGR2RGB))
plt.show()

# 문제 2: 이미지 뒤집기
# 목표: 주어진 이미지를 수평, 수직으로 뒤집는 기능을 구현합니다.
# 설명: 이미지를 수평, 수직으로 뒤집고 결과를 표시합니다.
# # 수평 뒤집기

# 수직 뒤집기

# 결과 표시
plt.imshow(cv2.cvtColor(flipped_img_hor, cv2.COLOR_BGR2RGB))
plt.show()
plt.imshow(cv2.cvtColor(flipped_img_ver, cv2.COLOR_BGR2RGB))
plt.show()

# 문제 3: 이미지 회전
# 목표: 주어진 이미지를 특정 각도로 회전시키는 기능을 구현합니다.
# 설명: 이미지를 45도 회전시키고 결과를 표시합니다.
# 회전을 위한 변환 행렬 생성
rows, cols, _ = img.shape
# 이미지 회전

# 결과 표시
plt.imshow(cv2.cvtColor(rotated_img, cv2.COLOR_BGR2RGB))
plt.show()

# 정답
# 문제 1
resized_img = cv2.resize(img, (200, 200), interpolation=cv2.INTER_LINEAR)
# 이미지 표시
plt.imshow(cv2.cvtColor(resized_img, cv2.COLOR_BGR2RGB))
plt.show()
# 문제 2
# # 수평 뒤집기
flipped_img_hor = cv2.flip(img, 1)
# 수직 뒤집기
flipped_img_ver = cv2.flip(img, 0)
# 결과 표시
plt.imshow(cv2.cvtColor(flipped_img_hor, cv2.COLOR_BGR2RGB))
plt.show()
plt.imshow(cv2.cvtColor(flipped_img_ver, cv2.COLOR_BGR2RGB))
plt.show()

# 문제 3
rows, cols, _ = img.shape
M = cv2.getRotationMatrix2D((cols/2, rows/2), 45, 1)
# 이미지 회전
rotated_img = cv2.warpAffine(img, M, (cols, rows))
# 결과 표시
plt.imshow(cv2.cvtColor(rotated_img, cv2.COLOR_BGR2RGB))
plt.show()

컴퓨터 비전 (Computer Vision) 이란?

1. 개요

• 컴퓨터 비전은 컴퓨터가 디지털 이미지를 이해하고 분석하여 의미 있는 정보를 추출하도록 하는 학문 및 기술 분야입니다.
• 인간의 시각 시스템처럼 이미지나 비디오를 처리하고 그 안의 객체, 패턴, 또는 행동을 이해하려는 목표를 가지고 있습니다.
• 컴퓨터 비전은 인공지능(AI)의 하위 분야로, 주로 기계 학습과 딥러닝 기술에 의존합니다.

2. 배경

1. 배경

• 컴퓨터 비전은 초기에는 간단한 영상 처리 기술(예: 에지 검출, 히스토그램 분석)을 중심으로 발전했습니다.
• 2000년대 이후 딥러닝 기술의 발전과 함께 컴퓨터 비전은 비약적으로 발전했습니다.
• 특히, 합성곱 신경망(CNN) 구조가 컴퓨터 비전 분야에서 큰 성과를 거두면서 기존 방법론을 대체하거나 보완하고 있습니다.

3. 주요 사용 사례

1. 이미지 분류(Image Classification):

   • 이미지를 입력받아 해당 클래스(예: 고양이, 강아지)를 분류.
   • 예: 구글 포토, 이미지 검색.

2. 객체 탐지(Object Detection)

   • 이미지 내 특정 객체의 위치와 종류를 식별.
   • 예: 자율 주행 차량의 보행자 탐지.

3. 이미지 분할(Image Segmentation)

   • 이미지를 픽셀 단위로 분석하여 영역별로 구분.
   • 예: 의료 영상 분석, 위성 이미지 처리.

4. 얼굴 인식(Face Recognition)

   • 얼굴 특징을 기반으로 개인을 식별.
   • 예: 스마트폰의 얼굴 잠금 해제.

5. 동작 인식(Action Recognition)

   • 비디오에서 사람의 동작을 인식.
   • 예: 스포츠 비디오 분석, 감시 시스템.

6. 이미지 생성(Image Generation)

   • GAN(생성적 적대 신경망) 또는 VAE를 사용하여 새로운 이미지를 생성.
   • 예: 딥페이크, 스타일 변환.

컴퓨터 이미지에 대한 이해

1. 컴퓨터 이미지 이해와 컴퓨터 비전의 연계

• 컴퓨터 이미지는 컴퓨터 비전의 핵심 기초 개념으로, 이미지 데이터를 어떻게 표현하고 처리하는지 이해하는 것이 중요합니다.

• 컴퓨터에서 이미지는 기본적으로 RGB 값으로 표현됩니다. RGB는 빨강(R), 녹색(G), 파랑(B) 세 가지 색의 조합으로 구성되며, 각 색의 강도는 0부터 255 사이의 정수 값으로 표현됩니다.

• 예시:

  • (0, 0, 0): 검정색
  • (255, 255, 255): 흰색
  • (255, 0, 0): 빨간색
  • (0, 255, 0): 녹색
  • (0, 0, 255): 파란색
  • (255, 0, 255): 핑크색

• 이러한 값들이 조합되어 이미지를 구성하며, 이미지의 크기에 따라 데이터의 양이 결정됩니다. 예를 들어, 1000 x 1000 크기의 이미지는 픽셀당 RGB(3개의 값)를 저장하므로 1000 x 1000 x 3 = 3,000,000개의 값이 필요합니다.

• color: 3차원 (true color 라고도 불림)

  

  [이미지 출처] https://en.wikipedia.org/wiki/RGB_color_space
  https://commons.wikimedia.org/wiki/File:RGB_color_space_animated_view.gif

• gray scale: 2차원

  • 0~255의 값을 통해 밝기를 표현
  • 0으로 갈수록 어두워지고, 255로 갈수록 밝아짐
  

  [이미지 출처] https://medium.com/@himnickson/converting-rgb-image-to-the-grayscale-image-in-java-9e1edc5bd6e7

  

  [이미지 출처] https://ai.stanford.edu/~syyeung/cvweb/tutorial1.html

2. 이미지 파일 포맷과 압축

• 이미지 데이터는 효율적인 저장과 전송을 위해 압축되어 사용됩니다. JPEG, PNG, GIF와 같은 파일 포맷이 대표적입니다.

• 주요 포맷:

  1. JPEG (Joint Photographic Experts Group):
  • 손실 압축 방식으로 파일 크기를 줄이는 데 효과적입니다.
  • 세부 정보를 일부 손실하지만 인간의 시각으로 인지하기 어려운 수준으로 처리됩니다.
  2. PNG (Portable Network Graphics):
  • 무손실 압축 방식으로, 이미지 품질이 그대로 유지됩니다.
  • 투명도(알파 채널)를 지원하여 그래픽 처리에 유용합니다.
  3. GIF (Graphics Interchange Format):

  • 애니메이션을 지원하며, 256가지 색상으로 제한되는 간단한 압축 방식입니다.

  • 이러한 압축 방식은 원래의 RGB 데이터를 효율적으로 압축하지만, 손실 압축 방식(JPEG 등)은 원본 데이터와 일부 차이가 발생할 수 있습니다. 압축된 데이터는 화면에 출력되기 전에 해당 포맷의 압축 해제 방식을 통해 RGB 값으로 복구됩니다. 하지만 손실된 데이터는 복구되지 않습니다.

3. 이미지에서 특징(feature)을 학습하는 방법

• 컴퓨터 비전에서는 이미지 데이터를 입력으로 받아 다양한 작업을 수행합니다. 이를 위해, 이미지의 RGB 값이 컴퓨터가 이해할 수 있는 형태로 변환됩니다.

• 이미지 데이터를 처리하는 과정:

  1. 데이터 전처리:

     • 이미지를 픽셀 값(RGB)로 변환.
     • 정규화(Normalization): RGB 값을 0 ~ 255 범위에서 0 ~ 1 사이의 값으로 변환하여 딥러닝 모델에 적합하게 만듦.
     • 이미지 크기 조정(Resizing): 네트워크에 맞는 입력 크기로 변환.

  2. 특징 추출:

     • 딥러닝 모델(특히 CNN)에서 이미지를 처리하며 특징(feature)을 학습.
     • 예: 에지(Edge), 텍스처(Texture), 패턴(Pattern) 등.
     • 기존 방법(딥러닝 이전의 방법): 수작업으로 특징을 추출하거나, 필터와 머신러닝 알고리즘을 활용.
     • 에지 검출 필터: 예를 들어, Sobel 필터, Canny Edge Detector 등을 사용하여 이미지의 윤곽선을 추출.
     • 추출된 특징을 사용하여 SVM(Support Vector Machine)이나 KNN(K-Nearest Neighbors) 같은 머신러닝 모델로 분류 작업 수행.

  3. 모델 적용:

  • 이미지 분류(Classification), 객체 탐지(Object Detection), 이미지 분할(Segmentation) 등 다양한 컴퓨터 비전 작업 수행.

• 딥러닝 모델(특히 CNN)은 입력 이미지를 픽셀의 RGB 값으로 받아서 공간적 정보(Spatial Information)를 학습합니다. 예를 들어, 이미지 분류 모델은 각 픽셀의 RGB 조합과 이들 간의 관계를 학습하여 이미지를 특정 클래스(예: 고양이, 강아지 등)로 분류합니다.

4. 결론

• 컴퓨터 이미지는 기본적으로 RGB 데이터의 조합으로 구성되며, 다양한 포맷으로 저장 및 전송됩니다. 컴퓨터 비전에서는 이러한 데이터를 처리하여 이미지의 패턴과 의미를 추출하고, 이를 기반으로 분류, 탐지, 생성 등 복잡한 작업을 수행합니다.

• 기존의 필터나 머신러닝 기반 접근법은 컴퓨터 비전 작업에서 효율적인 방법을 제공했지만, 딥러닝 기반 접근법은 데이터를 기반으로 직접 특징을 학습할 수 있어 더 복잡하고 정교한 작업을 수행할 수 있습니다.

• 따라서 컴퓨터 이미지의 기초 개념과 함께 전통적인 특징 추출 기법과 딥러닝 방법을 모두 이해하는 것이 컴퓨터 비전의 성공적인 활용에 필수적입니다.

파이썬에서 이미지 처리하기

주요 라이브러리 소개

OpenCV

• 소개:

  1. OpenCV(Open Source Computer Vision)는 실시간 컴퓨터 비전 및 이미지 처리에 중점을 둔 오픈소스 라이브러리입니다.
  2. 인텔(Intel)에서 개발하였으며, 현재는 전 세계적으로 가장 널리 사용되는 이미지 처리 도구 중 하나입니다.
  3. C++, Python, Java 등 여러 언어를 지원하며, 다양한 운영 체제에서 사용할 수 있습니다.
  4. TensorFlow, PyTorch, Caffe 등의 딥러닝 프레임워크와도 통합이 가능합니다.
  5. 주요 기능

  • 이미지 처리: 필터링, 히스토그램 계산, 에지 검출, 기하학적 변환 등

  • 비디오 분석: 객체 추적, 모션 추정

  • 머신러닝: 사전 정의된 알고리즘(SVM, KNN 등) 제공

  • 딥러닝 지원: 사전 학습된 모델과 ONNX 포맷을 활용한 딥러닝 작업 가능

    

    [이미지 출처] https://ko.wikipedia.org/wiki/OpenCV

Pillow

• 소개:

  1. Pillow는 PIL(Python Imaging Library)의 공식적인 확장판으로, Python에서 이미지 작업을 간단하고 직관적으로 수행할 수 있도록 설계된 라이브러리입니다.
  2. 다양한 이미지 파일 포맷(JPEG, PNG, BMP, GIF 등)을 지원하며, 이미지 열기, 저장, 변환, 편집 등이 가능합니다.
  3. 주요 기능

  • 이미지 읽기 및 저장: 다양한 포맷의 이미지를 읽고 저장할 수 있습니다.

  • 파일 형식 변환(예: PNG → JPEG 등)이 가능합니다.

  • 이미지 변환: 크기 조정(Resizing), 회전(Rotation), 색상 변경(Grayscale 변환 등)과 같은 작업을 쉽게 수행할 수 있습니다.

  • 이미지 필터링:블러(Blur), 샤프닝(Sharpening) 등 기본적인 필터링 기능 제공.

  • 텍스트 추가: 이미지를 배경으로 텍스트를 추가하는 기능 지원.

    

    [이미지 출처] https://www.linkedin.com/pulse/pil-library-functions-rahul-saxena

이미지와 넘파이 (NumPy)

• 이미지는 컴퓨터에서 픽셀 값의 배열로 표현되며, 이러한 배열은 Python의 NumPy를 사용하여 쉽게 처리할 수 있습니다.
• 컬러 이미지: 3차원 배열(높이, 너비, 채널)로 표현됩니다. 각 픽셀은 [R, G, B] 값을 가지며, 일반적으로 0~255 범위의 정수로 표현됩니다.
• 흑백 이미지: 2차원 배열로 표현되며, 각 픽셀은 0~255의 밝기 값으로 나타냅니다.
• NumPy는 이미지 데이터를 효율적으로 처리하기 위한 강력한 도구를 제공하며, OpenCV와 함께 사용하면 효과적입니다.

• 코드 참조 : https://opencv-python.readthedocs.io/en/latest/index.html

이미지 읽기와 출력

• 이미지 파일을 읽고 화면에 출력하기 위해 다양한 라이브러리를 사용할 수 있습니다. 각각의 특징과 적합한 환경을 살펴봅니다.

1. Pillow (PIL)와 Matplotlib
   • 구글 코랩(Google Colab)이나 Jupyter Notebook 같은 노트북 환경에서 적합합니다.
   • 간단한 이미지 읽기와 시각화에 적합하며, 사용법이 직관적입니다.
   • Matplotlib의 imshow()를 통해 이미지를 출력할 수 있습니다.
2. OpenCV
   • 주로 Python 스크립트 기반 환경에서 사용됩니다.
   • OpenCV의 cv2.imread() 함수로 이미지를 읽고, cv2.imshow()로 이미지를 출력할 수 있습니다.
   • 다만, Google Colab에서는 OpenCV의 기본 이미지 출력 함수인 cv2.imshow()가 지원되지 않기 때문에, Colab에서는 from google.colab.patches import cv2_imshow를 사용해야 합니다.
   • OpenCV는 이미지뿐 아니라 동영상 처리도 지원하지만, Colab에서는 동영상 관련 작업은 제약이 있습니다.

import cv2
import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline

from PIL import Image
import requests
from io import BytesIO

# url과 Image객체를 활용하여 이미지 읽기
url = 'https://cdn.pixabay.com/photo/2018/10/01/09/21/pets-3715733_960_720.jpg'

response = requests.get(url)
pic = Image.open(BytesIO(response.content))

이미지 출력 1

• 이미지 확인 (pillow)
  • Image 객체

pic

• 타입(type) 확인

print(type(pic))

<class 'PIL.JpegImagePlugin.JpegImageFile'>

• PIL 이미지를 array형으로 형변환
  • np.asarray()

pic_arr = np.asarray(pic)
print(type(pic_arr)) # 타입(type) 확인
print(pic_arr.shape) # HWC
print(pic_arr)

plt.imshow(pic_arr)

<matplotlib.image.AxesImage at 0x7fa57d35f2e0>

이미지 출력 2

• R, G, B 에 따라 이미지 확인

pic_copy = pic_arr.copy()
print(pic_copy[:,:,0])
print(pic_copy[:,:,0].shape)

[[214 214 215 ... 235 234 233]
 [214 215 215 ... 235 233 233]
 [215 215 215 ... 235 233 233]
 ...
 [211 211 211 ... 229 229 229]
 [211 211 211 ... 229 229 230]
 [211 211 211 ... 231 231 232]]
(640, 960)

• 채널 순서 (R G B : 0 1 2)
  • R channel

# cmap(컬러맵)은 1차원 데이터(단일 채널 이미지) 또는 2차원 배열에 색상을 매핑하기 위해 사용
plt.figure(figsize=(15,5))
plt.subplot(1,3,1)
plt.imshow(pic_copy[:,:,0], cmap='gray')
plt.subplot(1,3,2)
plt.imshow(pic_copy[:,:,1], cmap='gray')
plt.subplot(1,3,3)
plt.imshow(pic_copy[:,:,2], cmap='gray')
plt.show()

채널별 분포 확인

# R channel 분포 확인
pic_red = pic_arr.copy()
pic_red[:,:,1] = 0
pic_red[:,:,2] = 0

# G channel 분포 확인
pic_green = pic_arr.copy()
pic_green[:, :, 0] = 0
pic_green[:, :, 2] = 0

# B channel 분포 확인
pic_blue = pic_arr.copy()
pic_blue[:, :, 0] = 0
pic_blue[:, :, 1] = 0

plt.figure(figsize=(20,5))
plt.subplot(1,4,1)
plt.imshow(pic_arr)
plt.subplot(1,4,2)
plt.imshow(pic_red)
plt.subplot(1,4,3)
plt.imshow(pic_green)
plt.subplot(1,4,4)
plt.imshow(pic_blue)
plt.show()

이미지 출력 3

• OpenCV

• from google.colab.patches import cv2_imshow

  • 원래는 cv2.imshow

• 아래 이미지는 어색하게 보이는데 이는 OpenCV와 matplotlib의 색공간 순서가 다르기 때문에 생기는 문제임
• matploblib : R G B
• OpenCV : B G R

from google.colab.patches import cv2_imshow
cv2_imshow(pic_arr)

OpenCV 의 채널 순서

• OpenCV를 통해 영상(이미지)을 다룰 때의 채널 순서는 B G R

• matplotlib은 R G B 순서

• cv2.cvtColor(image arrary, 변경할 색공간) 함수를 이용하여 색공간을 변경해주면 정상적으로 시각화가 가능함

• 변경할 색공간은 여러 가지가 있음

  • cv2.COLOR_BGR2RGB

  • cv2.COLOR_RGB2GRAY

  • cv2.COLOR_GRAY2RGB

  • ...

image = cv2.cvtColor(pic_arr, cv2.COLOR_RGB2BGR)
cv2_imshow(image)

• image, pic_arr 비교

  • 0 1 2 인덱스 중 0, 2가 바뀐 것을 알 수 있음

print(image[0][0])

[140 123 214]

print(pic_arr[0][0])

[214 123 140]

• (참고) array[ : , : , : : -1] 을 통해서도 인덱스 순서를 바꿀 수 있음

temp_arr = pic_arr[:,:, ::-1]

print(pic_arr[0][0])

[214 123 140]

print(temp_arr[0][0])

[140 123 214]

• 전체 배열 확인

print(temp_arr)

print(pic_arr)

이미지 읽기 2

• cv2.imread()

  • path, 이미지 파일의 flag값을 인자로 넣어줌

    • cv2.IMREAD_COLOR
      이미지 파일을 Color로 읽어들이고, 투명한 부분은 무시되며, Default 값

    • cv2.IMREAD_GRAYSCALE
      이미지를 Grayscale로 읽음. 실제 이미지 처리시 중간단계로 많이 사용

    • cv2.IMREAD_UNCHANGED
      이미지 파일을 alpha channel (투명도)까지 포함하여 읽어 들임

• (주의)

  • cv2.imread()는 잘못된 경로로 읽어도 NoneType으로 들어갈 뿐, 오류를 발생하지 않음

• 이미지 다운로드 후 colab에 업로드

  • https://upload.wikimedia.org/wikipedia/ko/thumb/2/24/Lenna.png/220px-Lenna.png
  
  

from google.colab import files
files.upload()

image = cv2.imread('Lenna.png', cv2.IMREAD_UNCHANGED)

print(type(image))

<class 'numpy.ndarray'>

cv2_imshow(image)

plt.figure(figsize=(10,5))
plt.subplot(1,2,1)
plt.imshow(image)

plt.subplot(1,2,2)
image_temp = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
plt.imshow(image_temp)
plt.show()

• grayscale로 읽기

img_gray = cv2.imread('Lenna.png',cv2.IMREAD_GRAYSCALE)

print(img_gray.shape)

(220, 220)

cv2_imshow(img_gray)

plt.figure(figsize=(20,5))
plt.subplot(1,4,1)
plt.imshow(img_gray)
plt.subplot(1,4,2)
plt.imshow(img_gray, cmap='gray')
plt.subplot(1,4,3)
plt.imshow(img_gray, cmap='magma')
plt.subplot(1,4,4)
plt.imshow(img_gray, cmap='coolwarm')
plt.show()

이미지 저장

• cv2.imwrite()
  • 경로, 이미지 배열을 인자로 받음

random_image = np.random.randint(0,256, size=(200,200,3))
print(random_image.shape )

(200, 200, 3)

• 이미지 저장을 하면 True반환

cv2.imwrite('./random_image.png', random_image)

True

• 없는 이미지를 읽어도 type이 NoneType으로 들어갈 뿐 에러를 발생하지 않음

no_image = cv2.imread('no_image.png')
```![업로드중..](blob:https://velog.io/e83a72b1-5ec4-4d98-9d17-eadf54c1c5ca)



```python
type(no_image)

NoneType

my_image = cv2.imread('random_image.png')

print(type(my_image))
print(my_image.shape)

<class 'numpy.ndarray'>
(200, 200, 3)

cv2_imshow(my_image)

색 공간의 종류 (참고)

• RGB

  • 컬러 표현을 빛의 3원색인 (Red, Green, Blue)으로 서로 다른 비율을 통해 색 표현

• CMYK

  • Cyan, Magenta, Yellow, Black를 기본으로 하여 주로 컬러 프린터나 인쇄시에 사용

  • 각 성분들의 감산에 의해 컬러 구현

• YUV

  • Y축은 밝기 성분을 U,V 두축을 이용하여 색상을 표현

  • U축은 파란색에서 밝기 성분을 뺀 값, V축은 빨간색에서 밝기 성분을 뺀 값

  • 아날로그 컬러신호 변환에 주로 사용. (U = B - Y) , (V = R - Y)

• YCbCr

  • Digital TV에서 사용하는 색공간

  • YPbPr이라는 아날로그 신호의 색공간을 디지털화한 것

  • YPbPr은 아날로그 컴포넌트 비디오에서 사용

• 이미지

  • 이미지 사용 (다른 이미지 사용 가능)
  

  _{[이미지 출처] https://pixabay.com/ko/photos/%EA%B0%95%EC%95%84%EC%A7%80-%EA%B0%9C-%EC%95%A0%EC%99%84-%EB%8F%99%EB%AC%BC-%EB%8F%99%EB%AC%BC-1903313/}

files.upload()

origin_image = cv2.imread('dog.jpg')

• OpenCV와 matplotlib의 색공간 순서가 다르기 때문에 생기는 문제

  • matploblib : R G B

  • OpenCV : B G R

plt.imshow(origin_image)
plt.show()

img_rgb = cv2.cvtColor(origin_image, cv2.COLOR_BGR2RGB)

plt.imshow(img_rgb)

<matplotlib.image.AxesImage at 0x7fa56f3ddc60>

HSL Color Space

• 색상(Hue), 채도(Saturation), 밝기(Lightness)로 색을 표현하는 방식

• HSV와 동일하지만 밝기 요소의 차이

• HSV와 더불어 사람이 실제로 color를 인지하는 방식과 유사

  
  

  _{[이미지 출처] https://rgbtohex.page/hsl}

1.대규모 언어 모델과 RLHF

• RLHF (Reinforcement Learning with Human Feedback):
  • 사용 사례:
    • ChatGPT (OpenAI): 인간 피드백을 활용해 언어 모델의 응답 품질 향상.
    • InstructGPT: 사용자의 지침에 맞는 응답 생성.
  • 작동 원리:
    • 인간 평가자가 제공하는 피드백(보상 모델)을 기반으로, 언어 모델이 보상을 극대화하는 방향으로 미세 조정.
    • 예: 사용자 선호도가 높은 응답을 더 많이 생성하도록 학습.

ChatGPT에 적용된 RHLF (Reinforcement Learning with Human Feedback)

ChatGPT는 인간의 피드백을 활용해 보다 자연스럽고 유용한 답변을 생성하기 위해 RHLF 과정을 거칩니다. 이 과정은 크게 3단계로 나뉩니다.

1단계: Supervised Fine-Tuning (SFT)

• 목적: 사전 학습된 언어 모델(Pre-trained LM)이 인간이 의도한 정책(policy)을 따르도록 Fine-Tuning합니다.
• 방법:
  • 인간 Labeler(또는 Trainer)가 고품질의 소량 데이터셋을 선별합니다.
  • 이 데이터를 사용하여 사전 학습된 모델을 Fine-Tuning합니다.
• 결과: 인간의 의도를 반영한 초기 모델(SFT 모델)이 생성됩니다.

2단계: Reward Model 학습 (Mimic Human Preferences)

• 목적: 모델의 응답 품질을 평가하는 보상 모델(Reward Model)을 학습합니다.
• 방법:
  • SFT 모델이 생성한 여러 답변 후보를 수집합니다.
  • 인간 Labeler가 각 답변에 대해 랭킹을 매기고, 어떤 답변이 더 나은지 점수화한 데이터를 만듭니다.
  • 이 랭킹 데이터를 사용해 Reward Model을 학습시킵니다.
• 결과: 인간 선호도를 학습한 보상 모델이 생성됩니다.

3단계: 강화학습 (PPO를 이용한 Fine-Tuning)

• 목적: SFT 모델을 사용자 피드백과 Reward Model을 활용해 강화합니다.
• 방법:
  • 사용자 입력 데이터를 SFT 모델에 제공합니다.
  • SFT 모델이 생성한 답변을 Reward Model과 상호작용하여 평가합니다.
  • Proximal Policy Optimization(PPO, 정책을 직접 최적화하는 방식) 알고리즘을 사용해 SFT 모델을 업데이트합니다.
• 결과: 사용자 피드백을 반영한 최적화된 ChatGPT 모델이 완성됩니다.

요약

ChatGPT는 아래의 단계를 통해 인간 피드백을 최대한 반영한 모델로 발전합니다:

1. SFT: 인간의 의도를 반영한 초기 모델 학습.
2. Reward Model: 인간 선호도를 반영한 평가 모델 학습.
3. PPO 강화학습: 사용자 입력과 상호작용하며 최적화.

이를 통해 ChatGPT는 더 높은 품질의 응답을 생성할 수 있습니다.

2.게임 분야에서의 강화학습 활용 사례와 기술

• 강화학습은 게임 분야에서 인공지능(AI) 에이전트의 성능을 혁신적으로 향상시키며, 다양한 방식으로 활용되고 있습니다. 아래는 주요 사례와 적용된 기술들을 정리한 내용입니다.

1. AlphaGo와 AlphaGo Zero

• AlphaGo: DeepMind에서 개발한 AI로, 강화학습을 통해 바둑 게임을 마스터했습니다.
• AlphaGo Zero: 인간의 기보 데이터를 사용하지 않고, 자가 학습(self-play)만으로 최고 수준의 바둑 실력을 달성했습니다.

주요 기술:

• 심층 신경망을 사용하여 게임 상태를 평가하고 다음 수를 예측.
• 자가 대국(self-play)을 통한 강화학습.
• 몬테카를로 트리 탐색(MCTS) 없이 단일 신경망과 간단한 트리 탐색만으로 구현.

2. Atari 게임 마스터

• Google DeepMind의 Deep Q-Network (DQN)은 다양한 Atari 2600 게임을 플레이하며, 인간 수준 이상의 성과를 보여주었습니다.

주요 기술:

• 컨볼루션 신경망(CNN)을 사용해 raw 픽셀 입력으로부터 Q-함수를 학습.
• 경험 리플레이(Experience Replay)를 통한 안정적인 학습.
• 동일한 아키텍처와 하이퍼파라미터를 여러 게임에 적용하여 일반화된 성능을 달성.

강화학습의 게임 분야 적용 의의

이와 같은 사례들은 강화학습이 게임 AI 개발에 혁신을 가져오고 있음을 보여줍니다. 특히, 다음과 같은 측면에서 강화학습의 잠재력이 입증되고 있습니다:

• 복잡한 전략 수립: 바둑이나 MOBA 게임과 같은 복잡한 환경에서의 의사결정.
• 실시간 의사결정: 플레이어와의 실시간 상호작용.
• 적응형 게임플레이: 플레이어 행동에 맞춘 게임 난이도 조절.

강화학습은 게임 AI의 성능과 플레이 경험을 향상시키는 데 중요한 역할을 하고 있습니다.

3.로봇

• 로봇들은 수동으로 프로그래밍되는 대신 자율적으로 움직임을 학습했을 때 성능이 크게 향상되었음

• 또한 걷기와 축구뿐만 아니라 더 복잡한 운동 기술도 습득가능했음

• 로봇의 정교한 움직임을 위해 강화학습이 앞으로도 많이 활용될 것으로 미래 전망됨

  

  https://www.sciencenews.org/article/reinforcement-learn-ai-humanoid-robots

4.강화학습의 단점 및 한계점

• 보상이 드물게 주어지는 환경에서의 학습이 어려움
• 먼 미래에 주어지는 불확실한 보상과 가까운 미래의 큰 보상 사이 딜레마

1. 강화학습(RL): 에이전트가 환경과 상호작용하며 최적의 행동을 학습하는 과정.

   • 핵심 요소:
     • 상태(State): 현재 환경의 상태.
     • 행동(Action): 에이전트가 취할 수 있는 행동.
     • 보상(Reward): 행동의 결과로 환경이 에이전트에 제공하는 피드백.
     • 정책(Policy): 상태에 따라 행동을 결정하는 함수.
   • 목표: 보상을 최대로 만드는 정책 학습.

2. 딥러닝(DL): 심층 신경망을 사용하여 복잡한 패턴이나 함수를 모델링.

   • 강화학습의 비선형 함수 근사를 위해 딥러닝이 사용됨.

3. 심층 강화학습(DRL): 딥러닝과 강화학습의 융합.

   • Q-값, 정책 함수 등을 심층 신경망으로 근사.
   • 복잡한 환경에서도 학습 가능.

DQN (Deep Q-Network) 소개

• 전통적인 Q-Learning은 상태 공간이 클 경우 Q-테이블을 저장하기 어렵고, 일반화가 어려움.
• DQN은 심층 신경망(Deep Neural Network)을 사용하여 Q-값을 근사:
  • 입력: 상태(state).
  • 출력: 행동(action)에 대한 Q-값.

주요 특징

1. 경험 재생(Experience Replay):

   • 에이전트가 경험한 데이터를 저장하여 랜덤 샘플링으로 학습.
   • 데이터 간 상관성을 줄이고 학습 효율 향상.

2. 타겟 네트워크(Target Network):

   • Q-값 업데이트 안정성을 위해 메인 네트워크와 별도로 고정된 타겟 네트워크 사용.
   • 일정 간격으로 타겟 네트워크를 메인 네트워크의 가중치로 갱신.

1. Q-Learning 업데이트 수식

기존 Q-Learning에서는 다음과 같은 수식을 사용합니다:

$$ Q(s, a) \leftarrow Q(s, a) + \alpha \Big(r + \gamma max_{a'} Q(s', a') - Q(s, a) $\Big) $$

• $Q(s, a)$: 상태 $( s $)에서 행동 $( a $)를 했을 때의 Q-값 (예상 보상)
• $r $: 현재 행동 $( a $)를 통해 받은 보상
• $\gamma$: 할인율 (미래 보상을 현재 가치로 반영할 비율)
• $\alpha$: 학습률 (새로운 값과 기존 값의 반영 비율)
• $\max_{a'} Q(s', a') $: 다음 상태 $( s' $)에서 가능한 행동 중 가장 큰 Q-값

2. DQN의 업데이트 수식

DQN의 손실 함수는 "현재 시점에서의 Q값"과 "미래의 기대 보상으로 계산된 목표 Q값" 간의 차이를 줄이는 것을 목표로 합니다. 이를 통해 Q함수가 점점 더 정확하게 미래의 보상을 반영하게 되고, 에이전트가 최적의 행동을 학습할 수 있습니다.

DQN은 심층 신경망(Deep Neural Network)을 사용하여 $Q$값을 근사합니다. 업데이트를 위해 다음 손실 함수(Loss Function)를 사용합니다:

$$ \text{Loss} = \Big( r + \gamma \max_{a'} Q_{\text{target}}(s', a') - Q_{\text{main}}(s, a) \Big)^2 $$

• $Q_{\text{main}}(s, a)$: 메인 네트워크에서 예측한 Q-값
• $Q_{\text{target}}(s', a')$: 타겟 네트워크에서 계산한 Q-값 (고정된 값 사용)
• $r$: 현재 보상
• $\gamma \max_{a'} Q_{\text{target}}(s', a')$: 미래 보상의 예상치

이 손실 함수를 최소화하도록 메인 네트워크가 학습됩니다.

3. 경험 재생 (Experience Replay)

경험 재생은 DQN의 중요한 구성 요소 중 하나입니다. 이를 통해 신경망 학습의 안정성을 높입니다.

개념 설명:

• 에이전트는 환경과 상호작용하면서 경험을 만듭니다. 각 경험은 다음과 같은 형태로 저장됩니다:
  $(s, a, r, s', \text{done})$

  • $ s $: 현재 상태
  • $ a $: 행동
  • $ r $: 보상
  • $ s' $: 다음 상태
  • $\text{done}$: 에피소드 종료 여부 (True/False)

• 이러한 경험을 모두 메모리 버퍼(Replay Buffer)순차적으로 저장됩니다. 학습 시, 이 버퍼에서 랜덤 샘플링 을 통해 데이터를 추출해 신경망을 학습시킵니다.

왜 경험 재생이 필요한가?

1. 데이터 상관성 제거: 에이전트가 연속된 데이터를 사용하면 매우 비슷한 상태-행동 쌍이 반복적으로 등장하여, 모델이 특정 패턴에 편향될 가능성을 높입니다. 랜덤 샘플링을 통해 이를 방지합니다.
2. 데이터 재사용:
   • 경험 재생은 한 번의 경험을 여러 번 학습에 사용합니다. 이로 인해 새로운 데이터를 계속 생성하지 않아도 효율적으로 학습할 수 있습니다.
   • 이를 통해 더 적은 데이터로도 신경망을 효과적으로 학습시킬 수 있습니다.

쉽게 비유하면:

• 경험 재생은 과거의 학습 기록(노트)을 모아두고 복습하는 것과 같습니다.
• 즉, 에이전트가 과거 경험을 "기록"해두었다가 중요한 순간에 다시 꺼내 학습하는 방식입니다.
• 이를 통해 학습 과정에서 데이터가 부족하거나 연속된 데이터의 영향을 최소화할 수 있습니다.

4. 타겟 네트워크 (Target Network)

타겟 네트워크는 DQN 학습의 안정성을 높이는 기술입니다.

동작 원리:

• 메인 네트워크:

  1. 에이전트가 현재 상태에서 최적의 행동을 선택하도록 학습합니다.
  2. Q-값을 계산해 행동의 가치를 예측합니다.

• 타겟 네트워크:

  1. 메인 네트워크의 가중치를 일정 주기마다 복사해 고정된 상태로 유지합니다.
  2. 학습 중 목표값(Target Q-value)을 계산하는 데 사용됩니다.

왜 타겟 네트워크가 필요한가?

• DQN에서는 목표 Q-값(Target Q-value)을 예측하기 위해 메인 네트워크의 Q-값을 사용합니다. 하지만 이 값이 학습 중 계속 변한다면 목표값 자체가 흔들리며 학습이 불안정해질 수 있습니다.
• 타겟 네트워크는 일정 기간 동안 고정된 값을 제공하여 목표 Q-값을 안정적으로 유지하도록 돕습니다.
• 일정 주기마다 타겟 네트워크를 메인 네트워크로 업데이트하면서 최신 정보를 반영합니다.

쉽게 비유하면:

타겟 네트워크는 참고서와 같습니다. 참고서는 일정 시간 동안 바뀌지 않으므로 학습 목표가 흔들리지 않습니다. 대신 시간이 지나면 최신 정보를 반영해 갱신됩니다.

5. 전체 구조 정리

DQN의 학습 과정은 다음과 같습니다:

1. 환경과 상호작용하며 경험$( (s, a, r, s',\text{done})$)를 저장.
2. 메모리 버퍼에서 랜덤 샘플링을 통해 학습 데이터를 추출.
3. 메인 네트워크에서 현재 상태의 Q-값$( Q_{\text{main}}(s, a)$)를 예측.
4. 타겟 네트워크에서 목표 Q-값$(r +\gamma \max_{a'} Q_{\text{target}}(s', a'))$를 계산.
5. 손실 함수(Loss)를 계산하고 메인 네트워크를 업데이트.
6. 일정 주기마다 타겟 네트워크를 메인 네트워크로 동기화.

DQN 실습

간단한 OpenAI Gym 환경에서 DQN 모델을 구현하여 학습하는 과정을 실습합니다.

• 환경: CartPole-v1.
• 목표: 막대가 쓰러지지 않고 균형을 유지하도록 에이전트를 학습.
• 주요 구성 요소:
  1. 경험 재생(Experience Replay)을 위한 메모리 버퍼.
  2. 메인 네트워크와 타겟 네트워크.
  3. DQN 학습 루프.
• 종료 조건 :
  1. 막대의 각도가 일정 한계를 벗어나는 경우
  2. 정해진 일정 시간을 초과하는 경우

 # 필요한 라이브러리 임포트
import numpy as np  # 수학적 계산 및 배열 처리
import tensorflow as tf  # 딥러닝 프레임워크
from tensorflow.keras import Sequential  # 순차 모델
from tensorflow.keras.layers import Dense  # 신경망 층
from collections import deque  # 경험 재생 버퍼 구현을 위한 큐
import gym  # 강화학습 환경 제공 라이브러리

# CartPole-v1 환경을 생성하고 초기화
# render_mode="human"을 통해 환경 시각화
env = gym.make("CartPole-v1", render_mode="human")
state = env.reset()  # 초기 상태 가져오기

# 상태 공간의 크기와 행동 공간의 크기 정의
state_size = env.observation_space.shape[0]  # 상태의 차원 (카트의 위치, 속도, 막대의 각도, 각속도)
action_size = env.action_space.n  # 가능한 행동의 수 (왼쪽, 오른쪽)

# 경험 재생(Experience Replay)을 위한 버퍼 클래스
class ReplayBuffer:
    def __init__(self, max_size=50000):
        # 버퍼를 deque로 생성 (최대 크기 50000)
        self.buffer = deque(maxlen=max_size)

    def add(self, experience):
        # 새로운 경험 (state, action, reward, next_state, done)을 버퍼에 추가
        self.buffer.append(experience)

    def sample(self, batch_size):
        # 버퍼에서 무작위로 batch_size개의 샘플을 추출
        indices = np.random.choice(len(self.buffer), batch_size, replace=False)
        return [self.buffer[idx] for idx in indices]

    def size(self):
        # 현재 버퍼의 크기를 반환
        return len(self.buffer)

# Q값을 예측할 신경망 모델을 생성하는 함수
def build_model():
    # 순차 모델 생성
    model = Sequential([
        Dense(24, input_dim=state_size, activation='relu'),  # 첫 번째 은닉층 (입력: 상태 크기)
        Dense(24, activation='relu'),  # 두 번째 은닉층
        Dense(action_size, activation='linear')  # 출력층 (출력: 각 행동의 Q값)
    ])
    # 모델 컴파일 (Adam 옵티마이저, 손실 함수: MSE)
    model.compile(optimizer=tf.keras.optimizers.Adam(learning_rate=0.001), loss='mse')
    return model

# DQN 에이전트 클래스
class DQNAgent:
    def __init__(self):
        # 주 신경망 (Main Network) 생성
        self.main_model = build_model()
        # 타겟 신경망 (Target Network) 생성
        self.target_model = build_model()
        # 타겟 신경망의 가중치를 주 신경망과 동일하게 초기화
        self.target_model.set_weights(self.main_model.get_weights())
        # 경험 재생 버퍼 초기화
        self.replay_buffer = ReplayBuffer()
        # 하이퍼파라미터 설정
        self.gamma = 0.99  # 할인 계수 (미래 보상의 중요도)
        self.epsilon = 1.0  # 탐험률 초기값
        self.epsilon_decay = 0.995  # 탐험률 감소 비율
        self.epsilon_min = 0.01  # 최소 탐험률
        self.batch_size = 64  # 학습 배치 크기

    def update_target_network(self):
        # 타겟 신경망의 가중치를 주 신경망의 가중치로 업데이트
        self.target_model.set_weights(self.main_model.get_weights())

    def select_action(self, state):
        # 입실론-그리디 정책에 따라 행동 선택
        if np.random.rand() <= self.epsilon:
            # 무작위 행동 선택 (탐험)
            return env.action_space.sample()
        # 주 신경망을 통해 Q값 예측
        q_values = self.main_model.predict(state)
        # 가장 큰 Q값을 가진 행동 선택 (활용)
        return np.argmax(q_values[0])

    def train(self):
        # 경험 재생 버퍼에서 배치를 샘플링하여 학습
        if self.replay_buffer.size() < self.batch_size:
            return  # 버퍼 크기가 배치 크기보다 작으면 학습하지 않음

        # 배치 샘플링
        batch = self.replay_buffer.sample(self.batch_size)
        states, actions, rewards, next_states, dones = zip(*batch)
        states = np.array(states).squeeze(axis=1)  # 현재 상태
        next_states = np.array(next_states).squeeze(axis=1)  # 다음 상태

        # 현재 상태에 대한 Q값 예측
        target_qs = self.main_model.predict(states)
        # 다음 상태에 대한 Q값 예측 (타겟 네트워크 사용)
        next_qs = self.target_model.predict(next_states)

        # Q-Learning 업데이트 규칙 적용
        for i in range(self.batch_size):
            if dones[i]:  # 종료 상태에서는 보상만 반영
                target_qs[i][actions[i]] = rewards[i]
            else:  # 비종료 상태에서는 보상 + 할인된 미래 보상 반영
                target_qs[i][actions[i]] = rewards[i] + self.gamma * np.max(next_qs[i])

        # 주 신경망 학습
        self.main_model.fit(states, target_qs, epochs=1, verbose=0, batch_size=32)

# DQN 에이전트 생성
agent = DQNAgent()
episodes = 500  # 학습할 에피소드 수

# 학습 루프
for episode in range(episodes):
    state = env.reset()  # 환경 초기화 및 상태 가져오기
    state = state[0] if isinstance(state, tuple) else state  # 상태가 튜플이면 첫 번째 요소 사용
    state = np.reshape(state, [1, state_size])  # 상태를 2D 배열로 변환
    total_reward = 0
    done = False

    while not done:
        # 행동 선택
        action = agent.select_action(state)

        # 환경에서 한 스텝 진행
        step_result = env.step(action)
        if len(step_result) == 4:  # Gym 반환값 처리
            next_state, reward, done, info = step_result
        elif len(step_result) == 5:  # 일부 버전에서 반환값 추가 처리
            next_state, reward, done, truncated, info = step_result
            done = done or truncated  # truncated를 종료 조건으로 처리
        else:
            raise ValueError(f"Unexpected step result length: {len(step_result)}")

        next_state = next_state[0] if isinstance(next_state, tuple) else next_state
        next_state = np.reshape(next_state, [1, state_size])  # 다음 상태 변환

        # 경험을 리플레이 버퍼에 저장
        agent.replay_buffer.add((state, action, reward, next_state, done))

        state = next_state  # 상태 업데이트
        total_reward += reward  # 총 보상 업데이트

        # 에이전트 학습
        agent.train()

    # 10 에피소드마다 타겟 네트워크 업데이트
    if episode % 10 == 0:
        agent.update_target_network()

    # 탐험률 감소
    if agent.epsilon > agent.epsilon_min:
        agent.epsilon *= agent.epsilon_decay

    # 에피소드 정보 출력
    if episode % 10 == 0:
        print(f"Episode: {episode}, Total Reward: {total_reward}, Epsilon: {agent.epsilon:.2f}")

# 환경 종료
env.close()

학습 결과를 비디오로 저장

import os
from gym.wrappers import RecordVideo

# 비디오 저장 경로 설정
video_save_path = "./cartpole_videos"
os.makedirs(video_save_path, exist_ok=True)

# CartPole 환경을 생성하고 비디오 저장 설정
env = gym.make("CartPole-v1", render_mode="rgb_array")  # 비디오 저장용 환경 생성
env = RecordVideo(env, video_save_path, episode_trigger=lambda x: True)  # 모든 에피소드 비디오 저장

def play_and_record(agent, env, episodes=5):
    """
    학습된 에이전트가 환경을 플레이하며 비디오를 저장하는 함수.

    Args:
        agent: 학습된 DQN 에이전트.
        env: 비디오를 기록할 Gym 환경.
        episodes: 에이전트가 플레이할 에피소드 수.
    """
    for episode in range(episodes):
        state = env.reset()
        state = state[0] if isinstance(state, tuple) else state  # 상태가 튜플이면 첫 번째 요소 사용
        state = np.reshape(state, [1, state_size])  # 상태를 2D 배열로 변환
        total_reward = 0
        done = False

        while not done:
            # 학습된 네트워크로 행동 선택 (탐험 없이 활용만 수행)
            q_values = agent.main_model.predict(state)
            action = np.argmax(q_values[0])  # 가장 높은 Q값을 가진 행동 선택

            # 환경에서 한 스텝 진행
            step_result = env.step(action)
            if len(step_result) == 4:  # Gym 반환값 처리
                next_state, reward, done, info = step_result
            elif len(step_result) == 5:  # 일부 버전에서 반환값 추가 처리
                next_state, reward, done, truncated, info = step_result
                done = done or truncated  # truncated를 종료 조건으로 처리
            else:
                raise ValueError(f"Unexpected step result length: {len(step_result)}")

            next_state = next_state[0] if isinstance(next_state, tuple) else next_state
            next_state = np.reshape(next_state, [1, state_size])  # 다음 상태 변환

            state = next_state  # 상태 업데이트
            total_reward += reward  # 총 보상 업데이트

        print(f"Episode: {episode + 1}, Total Reward: {total_reward}")

# 학습된 에이전트로 플레이하며 비디오 저장
play_and_record(agent, env, episodes=5)

# 비디오 저장 완료 후 환경 종료
env.close()

print(f"비디오가 '{video_save_path}'에 저장되었습니다.")

생성된 비디오 재생

from IPython.display import HTML
import base64

def display_video(video_path):
    """저장된 비디오를 Jupyter Notebook에서 재생"""
    with open(video_path, "rb") as video_file:
        video_data = video_file.read()
    encoded_video = base64.b64encode(video_data).decode("utf-8")
    return HTML(f"""
        <video width="640" height="480" controls>
            <source src="data:video/mp4;base64,{encoded_video}" type="video/mp4">
        </video>
    """)

# 비디오 파일 경로
video_file_path = f"{video_save_path}/rl-video-episode-4.mp4"
display_video(video_file_path)

가비아에 로그인한 후, DNS 관리 페이지(예: 가비아 DNS 관리)로 이동합니다. 여기서 도메인에 대해 다음과 같이 DNS 레코드를 설정합니다. 링크 : https://dns.gabia.com/dns/internals/total_set

DNS 레코드 예시

• 타입: A
• 호스트: @
• 값: 서버의 공인 IP 주소
• TTL(Time To Live): 600

TTL(Time To Live)란?

• TTL은 DNS 레코드가 DNS 서버나 클라이언트에 캐시되어 있는 시간을 초 단위로 나타낸 값입니다.
• 예를 들어, TTL이 600초로 설정되어 있으면, 변경 사항이 최대 600초(10분) 후에 반영될 수 있다는 의미입니다.
• TTL 값을 낮추면 DNS 변경사항이 더 빠르게 반영되지만, 너무 낮게 설정하면 잦은 DNS 조회로 인해 부하가 증가할 수 있으므로 적당한 값을 선택하는 것이 좋습니다.
• 따라서, TTL 600은 일반적인 설정으로 적당합니다.

이렇게 설정하면, 도메인(example.com)서버의 IP 주소를 가리키게 되어 웹 브라우저에서 접속할 수 있습니다.

이후 보안을 포함한 부하 분산, SSL 인증서 적용 등을 편리하게 하기 위해 Nginx를 적용하겠습니다.

그렇게되면 외부에서 서버로 바로 요청이 들어오는게 아니라, Nginx가 역방향 프록시 역할을 하여 클라이언트의 요청을 받아 내부 서버로 전달하게 됩니다.

예를 들어 fastapi를 이용해 웹서버를 구축했다면, 클라이언트 -> fastapi 서버 방식이 아니라 클라이언트 -> Nginx -> fastapi 단계로 이루어져 중간에서 SSL 통신 처리, 부하분산 등의 역할을 손쉽게 도와줍니다.

2. Nginx를 이용한 역방향 프록시 구성

보안을 강화하고 부하 분산, SSL 인증서 적용 등을 용이하게 하기 위해 Nginx를 사용합니다. Nginx는 외부에서 들어오는 요청을 받아 내부의 FastAPI 서버(예: uvicorn)로 전달하는 역방향 프록시(reverse proxy) 역할을 합니다.

예를 들어 FastAPI 애플리케이션을 uvicorn으로 실행하면, 직접 외부에서 접속하는 방식(클라이언트 → FastAPI)보다는 클라이언트 → Nginx → FastAPI 방식으로 요청이 전달되어, Nginx에서 SSL 종료, 요청 헤더 처리, 부하 분산 등의 추가 기능을 활용할 수 있습니다

Nginx 적용 방법 (우분투 기준)

1. Nginx 설치

   sudo apt update
   sudo apt install nginx

2. Nginx 설정 파일 작성 /etc/nginx/sites-available/ 디렉토리에 새로운 설정 파일(예: fastapi.conf)을 생성합니다.

   sudo vi /etc/nginx/sites-available/fastapi.conf

   아래와 같이 내용을 입력합니다. (이 설정은 외부의 80 포트로 들어온 요청을 내부의 127.0.0.1:8000 포트로 전달합니다.)

   server {
    listen 80;
    server_name example.com www.example.com;  # 구매한 도메인 입력
   
    location / {
        proxy_pass http://127.0.0.1:8000;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
   }

3. 방화벽(UFW) 설정

• 외부에서 80 포트(HTTP)와 443 포트(HTTPS)에 접근할 수 있도록 UFW 설정을 업데이트합니다.

  sudo ufw allow 80/tcp
  sudo ufw allow 443/tcp # HTTPS를 사용

4. nginx 설정 활성화 및 재시작

• sites-available에 작성한 설정 파일을 sites-enabled에 심볼릭 링크로 등록합니다.

sudo ln -s /etc/nginx/sites-available/fastapi.conf /etc/nginx/sites-enabled/

• 설정 문법을 확인한 후 Nginx를 재시작합니다

  sudo nginx -t  # 설정 파일 (문법)테스트
  sudo systemctl restart nginx # 재시작

5.SSL 인증서 적용 (Certbot 사용) SSL을 적용하여 HTTPS 통신을 가능하게 하려면 Certbot을 사용합니다.

sudo apt install certbot python3-certbot-nginx
sudo certbot --nginx -d example.com -d www.example.com

참고 : Nginx 명령어

Nginx 상태 조회 명령어
sudo systemctl status nginx 

Nginx 시작 명령어
sudo systemctl start nginx

Nginx 중지 명령어
sudo systemctl stop nginx
재시작
sudo systemctl restart nginx

Nginx 자동 시작 설정: 서버 부팅 시 Nginx가 자동으로 시작되도록 설정하려면 다음 명령어를 사용합니다.
sudo systemctl enable nginx

위 설정을 완료하면, 서버의 IP 주소 대신 도메인으로 웹사이트에 접속할 수 있으며, Nginx가 역방향 프록시로 작동하여 FastAPI 애플리케이션으로 요청을 전달합니다. 또한, Certbot을 통한 SSL 인증서 적용으로 HTTPS 연결도 사용할 수 있습니다.

이제 여러분의 도메인을 통해 안전하고 효율적인 웹 서비스 운영이 가능합니다.

따라서 거래소마다 가격이 다른 것을 이용해 가격이 싼 곳에서 구매한 뒤 비싼곳에서 사면 적은 리스크로 돈을 벌 수 있고 이것을 무위험 차익거래 혹은 재정거래라고 부른다.

돈을 입금하면 재정거래를 자동으로 수행해주는 일부 서비스가 있지만, 수수료가 매우 크고 서비스 자체가 폐업해버리면 자산을 잃을 수 있기에 파이썬을 활용하여 재정거래 시스템을 직접 구축해보기로 했다.

제대로 돈을 벌기 위해서는 시중에 존재하는 대부분의 거래소를 탐색하여 가장 가격차이가 큰 두곳을 타겟으로 해야겠지만, 사람이 거래를 하는것과 달리 API를 이용한 프로그래밍 방식은 보안 절차가 상당히 까다로우며 시간이 많이 걸린다. 따라서 이번에는 업비트와 바이낸스 두 거래소를 타겟으로 하여 간단히 진행해본다.

1. 사전 준비 과정

우선 두 거래소 모두 아래 절차를 진행한다.

1. 거래에서 사용할 API 주소 발급 과정
2. 출금이 가능한 지갑 주소(Whitelist)를 등록

1번은 자료가 많기에 생략한다. 2번의 경우 API를 이용해 제 3자에게 암호화폐가 출금되는 상황은 위험하기에, 본인의 지갑 주소로 검증이 된 주소로만 화폐 전송을 허가하기 위함이다. 이는 휴대폰 인증을 통해서 등록하는 절차를 각 거래소마다 필수적으로 진행해주어야 한다.

1.1 바이낸스에서 업비트 출금 주소 등록하기

• 링크 : https://www.binance.com/en/my/security/address-management
• 아래 사진에 나와 있는 것처럼 whitelist에 암호 화폐별 지갑 주소를 별도 등록 해야한다.

1.2 업비트에서 바이낸스 출금 주소 등록하기

• 마이페이지 -> Open API 관리 -> 디지털 자산 출금주소 관리
• 링크 : https://upbit.com/mypage/open_api_management?tab=fund_source

바이낸스와 업비트에서 출금이 가능한 주소를 직접 등록하게 되면, API를 통한 거래시 해당 주소로 출금이 가능해진다. 주소를 등록할때 휴대폰 인증을 통한 절차가 두 플랫폼 모두에 존재했기 때문에 꽤 안전하다고 느껴진다.

2. 파이썬 재정거래 시스템 구축

2.1 환경 설정

API를 활용한 수월한 거래를 위해 각 거래소에서 제공하는 API기능을 적극 활용한다. 이때, 주요 기능이 잘 구현된 라이브러리를 활용하면 수월하게 작업이 가능하다. 설치 명령어는 다음과 같다.

pip3 install python-binance
pip3 install pyupbit
pip3 install upbit-client

이후 본인의 API키를 .env파일에 잘 저장해준 뒤, 작업 파일에서 각 라이브러리를 임포트하고, API키를 불러와서 거래소 클라이언트 객체를 생성하는 과정은 다음과 같다.

import time
import csv
import os
import requests                     # 환율 조회용
import pyupbit                      # 가격 데이터 조회용
from binance.client import Client   # 바이낸스 API 사용
from binance.exceptions import BinanceAPIException
from upbit.client import Upbit as UpbitClient  # Upbit 공식 클라이언트
from dotenv import load_dotenv

# API KEY 정보로드
load_dotenv()

# ===== API Key/Secret =====
BINANCE_API_KEY    = os.environ.get('BINANCE_API_KEY')
BINANCE_API_SECRET = os.environ.get('BINANCE_API_SECRET')
UPBIT_ACCESS_KEY   = os.environ.get('UPBIT_ACCESS_KEY')
UPBIT_SECRET_KEY   = os.environ.get('UPBIT_SECRET_KEY')

# ===== 거래소 클라이언트 객체 생성 =====
binance_client = Client(BINANCE_API_KEY, BINANCE_API_SECRET)
upbit_client = UpbitClient(UPBIT_ACCESS_KEY, UPBIT_SECRET_KEY)

여기까지 큰 문제 없이 진행되었다면, 아래 코드를 이용하여 본인 거래소 계좌에 있는 암호화폐 정보를 출력할 수 있을 것이다.

# -------------------------------
# 1. 각 거래소 잔고 출력
# -------------------------------

def print_upbit_balance():
    try:
        # Upbit 공식 클라이언트의 Account_info() 메서드를 사용하여 잔고 정보 조회
        resp = upbit_client.Account.Account_info()
        print("==== Upbit 잔고 정보 ====")
        for asset in resp['result']:
            balance = float(asset.get("balance", 0))
            if balance > 0:
                print(f"{asset['currency']}: {balance}")
    except Exception as e:
        print("Upbit 잔고 출력 오류:", e)

def print_binance_balance():
    try:
        # Binance의 계좌 정보를 조회하여 각 자산별 잔고 출력
        account_info = binance_client.get_account()
        print("==== Binance 잔고 정보 ====")
        for asset in account_info['balances']:
            free = float(asset.get('free', 0))
            locked = float(asset.get('locked', 0))
            total = free + locked
            if total > 0:
                print(f"{asset['asset']}: {total} (free: {free}, locked: {locked})")
    except Exception as e:
        print("Binance 잔고 출력 오류:", e)

# -------------------------------
# 2. 보유 코인 목록 및 양 출력
# -------------------------------

def print_upbit_coin_holdings():
    try:
        resp = upbit_client.Account.Account_info()
        print("==== Upbit 보유 코인 목록 ====")
        for asset in resp['result']:
            currency = asset.get("currency")
            # KRW는 기본 자산이므로 코인 목록에서는 제외할 수 있음 (필요 시 출력)
            if currency != "KRW":
                balance = float(asset.get("balance", 0))
                if balance > 0:
                    print(f"{currency}: {balance}")
    except Exception as e:
        print("Upbit 코인 보유량 출력 오류:", e)

def print_binance_coin_holdings():
    try:
        account_info = binance_client.get_account()
        print("==== Binance 보유 코인 목록 ====")
        for asset in account_info['balances']:
            asset_name = asset.get("asset")
            # USDT와 같이 기본 자산은 제외할 수 있음 (필요 시 출력)
            if asset_name != "USDT":
                free = float(asset.get("free", 0))
                locked = float(asset.get("locked", 0))
                total = free + locked
                if total > 0:
                    print(f"{asset_name}: {total} (free: {free}, locked: {locked})")
    except Exception as e:
        print("Binance 코인 보유량 출력 오류:", e)



print_upbit_balance()
print_binance_balance()
print_upbit_coin_holdings()
print_binance_coin_holdings()

다음은 각 거래소 클라이언트 객체를 이용해 원하는 코인을 매수하는 코드 예시다.

업비트 시장가 매수

resp = upbit_client.Order.Order_new(
    market=symbol,
    side='bid', # bid : 매수 , ask : 매도
    #volume='10', # 주문량
    price='30', # 주문 가격
    ord_type='price' #  limit: 지정가 주문, price: 시장가 주문 (매수), market: 시장가 주문 (매도)
)
print(resp['result'])

위 코드를 실행하면 현재 시장가격대로 30개를 매수하게 된다. 하지만 위 방법을 사용하는것은 비추천한다. 왜냐하면 업비트의 가격 산출 방식에 심각한 문제가 있기 때문이다.

아래 사진을 보자. 화면에 나와있는 대로 API를 통해 시장가 조회를 하거나 업비트 홈페이지에서 현재 가격을 확인하면 0.4269 USDT인 것을 확인할 수 있다. 하지만 우측 하단을 보면 꽤 오래전부터 가격이 0.3 USDT 이하로 유지되고 있었음을 알 수 있다.

이로 인해 당시 가치보다 지나치게 비싸게 코인이 매수되어 손실을 보게 되었다. 암호화폐를 매수할 때는 지정가로 구매하도록 하자. 지정가를 이용해서 구매하는 코드는 아래와 같다.

resp = upbit_client.Order.Order_new(
    market=symbol,
    side='bid', # bid : 매수 , ask : 매도
    volume='10', # 주문량
    price='0.26', # 주문 가격
    ord_type='price' #  limit: 지정가 주문, price: 시장가 주문 (매수), market: 시장가 주문 (매도)
)
print(resp['result'])

이후 API를 통한 거래가 가능하도록 출금 주소가 Whitelist에 잘 등록되었는지 확인하는 절차를 진행한다.

• 손으로 쓴 숫자들로 이루어진 이미지 데이터셋
• 기계 학습 분야의 트레이닝 및 테스트에 널리 사용되는 데이터
• keras.datasets에 기본으로 포함되어 있는 데이터셋

모듈 임포트

import tensorflow as tf
from tensorflow.keras.datasets.mnist import load_data
from tensorflow.keras.models import Sequential
from tensorflow.keras import models
from tensorflow.keras.layers import Dense, Input, Flatten
from tensorflow.keras.utils import to_categorical

from sklearn.model_selection import train_test_split
import numpy as np
import matplotlib.pyplot as plt

데이터 로드 및 전처리

• MNIST 데이터셋을 로드
• Train Data 중, 30%를 검증 데이터(validation data)로 사용

(x_train_full, y_train_full), (x_test, y_test) = load_data(path='mnist.npz')
x_train, x_val, y_train, y_val = train_test_split(x_train_full, y_train_full, test_size=0.3, random_state=111)

# random_state 검증, random_state=111 여부에 따른 값 변화 확인
# train_test_split(x_train_full, y_train_full, test_size=0.3)[0][33].sum()

num_x_train = x_train.shape[0]
num_x_val = x_val.shape[0]
num_x_test = x_test.shape[0]

print(f"기존학습데이터 : {x_train_full.shape} 레이블 : {y_train_full.shape}")
print(f"학습데이터 : {x_train.shape} 레이블 : {y_train.shape}")
print(f"검증데이터 : {x_val.shape} 레이블 : {y_val.shape}")
print(f"테스트데이터 : {x_test.shape} 레이블 : {y_test.shape}")

기존학습데이터 : (60000, 28, 28) 레이블 : (60000,)
학습데이터 : (42000, 28, 28) 레이블 : (42000,)
검증데이터 : (18000, 28, 28) 레이블 : (18000,)
테스트데이터 : (10000, 28, 28) 레이블 : (10000,)

num_sample = 5
random_idx = np.random.randint(60000, size=num_sample)

plt.figure(figsize=(15,3))
for idx, i in enumerate(random_idx):
    img = x_train_full[i, :]
    label = y_train_full[i]

    plt.subplot(1,len(random_idx), idx+1) # 행 / 열 / 위치
    plt.imshow(img)
    plt.title(f'index: {i}, label: {label}')

# 0 ~ 1 사이 값으로 nomalization (정규화)
# 0 ~ 1 값으로 바꿔주면 학습이 잘됨
x_train = x_train / 255.
x_val = x_val / 255.
x_test = x_test / 255.

y_train = to_categorical(y_train)
y_val = to_categorical(y_val)
y_test = to_categorical(y_test)

모델 구성(Sequential)

model = Sequential([
    Input(shape=(28,28)),
    Flatten(input_shape = [28,28], name = 'flatten'),
    Dense(100, activation='relu'),
    Dense(64, activation='relu'),
    Dense(32, activation='relu'),
    Dense(10, activation='softmax')])

model.summary()

Model: "sequential_2"

┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓
┃ Layer (type)                    ┃ Output Shape           ┃       Param # ┃
┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩
│ flatten (Flatten)               │ (None, 784)            │             0 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ dense_8 (Dense)                 │ (None, 100)            │        78,500 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ dense_9 (Dense)                 │ (None, 64)             │         6,464 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ dense_10 (Dense)                │ (None, 32)             │         2,080 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ dense_11 (Dense)                │ (None, 10)             │           330 │
└─────────────────────────────────┴────────────────────────┴───────────────┘

 Total params: 87,374 (341.30 KB)

 Trainable params: 87,374 (341.30 KB)

 Non-trainable params: 0 (0.00 B)

모델 컴파일 및 학습

model.compile(loss='categorical_crossentropy', 
              optimizer='adam',
            metrics=['accuracy'])

history = model.fit(x_train, y_train,
                    epochs = 50,
                    batch_size = 128,
                    validation_data=(x_val, y_val))

Epoch 1/50
329/329 ━━━━━━━━━━━━━━━━━━━━ 2s 2ms/step - accuracy: 0.7467 - loss: 0.8140 - val_accuracy: 0.9292 - val_loss: 0.2333
Epoch 2/50
329/329 ━━━━━━━━━━━━━━━━━━━━ 1s 2ms/step - accuracy: 0.9432 - loss: 0.1954 - val_accuracy: 0.9538 - val_loss: 0.1530
Epoch 3/50
329/329 ━━━━━━━━━━━━━━━━━━━━ 1s 2ms/step - accuracy: 0.9610 - loss: 0.1314 - val_accuracy: 0.9559 - val_loss: 0.1394
Epoch 4/50
329/329 ━━━━━━━━━━━━━━━━━━━━ 1s 2ms/step - accuracy: 0.9688 - loss: 0.1043 - val_accuracy: 0.9636 - val_loss: 0.1167
Epoch 5/50
329/329 ━━━━━━━━━━━━━━━━━━━━ 1s 2ms/step - accuracy: 0.9756 - loss: 0.0790 - val_accuracy: 0.9656 - val_loss: 0.1105
Epoch 6/50
329/329 ━━━━━━━━━━━━━━━━━━━━ 1s 2ms/step - accuracy: 0.9798 - loss: 0.0632 - val_accuracy: 0.9645 - val_loss: 0.1141
Epoch 7/50
329/329 ━━━━━━━━━━━━━━━━━━━━ 1s 2ms/step - accuracy: 0.9826 - loss: 0.0567 - val_accuracy: 0.9679 - val_loss: 0.1069
Epoch 8/50
329/329 ━━━━━━━━━━━━━━━━━━━━ 1s 2ms/step - accuracy: 0.9866 - loss: 0.0447 - val_accuracy: 0.9707 - val_loss: 0.1013
Epoch 9/50
329/329 ━━━━━━━━━━━━━━━━━━━━ 1s 2ms/step - accuracy: 0.9901 - loss: 0.0346 - val_accuracy: 0.9693 - val_loss: 0.1078
Epoch 10/50
329/329 ━━━━━━━━━━━━━━━━━━━━ 1s 2ms/step - accuracy: 0.9900 - loss: 0.0335 - val_accuracy: 0.9686 - val_loss: 0.1153
Epoch 11/50
329/329 ━━━━━━━━━━━━━━━━━━━━ 1s 2ms/step - accuracy: 0.9897 - loss: 0.0301 - val_accuracy: 0.9716 - val_loss: 0.1054
Epoch 12/50
329/329 ━━━━━━━━━━━━━━━━━━━━ 1s 2ms/step - accuracy: 0.9926 - loss: 0.0229 - val_accuracy: 0.9673 - val_loss: 0.1208
Epoch 13/50
329/329 ━━━━━━━━━━━━━━━━━━━━ 1s 2ms/step - accuracy: 0.9939 - loss: 0.0189 - val_accuracy: 0.9714 - val_loss: 0.1072
Epoch 14/50
329/329 ━━━━━━━━━━━━━━━━━━━━ 1s 2ms/step - accuracy: 0.9946 - loss: 0.0170 - val_accuracy: 0.9697 - val_loss: 0.1180
Epoch 15/50
329/329 ━━━━━━━━━━━━━━━━━━━━ 1s 2ms/step - accuracy: 0.9931 - loss: 0.0235 - val_accuracy: 0.9726 - val_loss: 0.1171
Epoch 16/50
329/329 ━━━━━━━━━━━━━━━━━━━━ 1s 2ms/step - accuracy: 0.9972 - loss: 0.0112 - val_accuracy: 0.9689 - val_loss: 0.1356
Epoch 17/50
329/329 ━━━━━━━━━━━━━━━━━━━━ 1s 2ms/step - accuracy: 0.9949 - loss: 0.0152 - val_accuracy: 0.9700 - val_loss: 0.1323
Epoch 18/50
329/329 ━━━━━━━━━━━━━━━━━━━━ 1s 2ms/step - accuracy: 0.9973 - loss: 0.0089 - val_accuracy: 0.9711 - val_loss: 0.1271
Epoch 19/50
329/329 ━━━━━━━━━━━━━━━━━━━━ 1s 2ms/step - accuracy: 0.9967 - loss: 0.0104 - val_accuracy: 0.9692 - val_loss: 0.1376
Epoch 20/50
329/329 ━━━━━━━━━━━━━━━━━━━━ 1s 2ms/step - accuracy: 0.9962 - loss: 0.0126 - val_accuracy: 0.9721 - val_loss: 0.1335
Epoch 21/50
329/329 ━━━━━━━━━━━━━━━━━━━━ 1s 2ms/step - accuracy: 0.9949 - loss: 0.0151 - val_accuracy: 0.9703 - val_loss: 0.1429
Epoch 22/50
329/329 ━━━━━━━━━━━━━━━━━━━━ 1s 2ms/step - accuracy: 0.9946 - loss: 0.0186 - val_accuracy: 0.9715 - val_loss: 0.1336
Epoch 23/50
329/329 ━━━━━━━━━━━━━━━━━━━━ 1s 2ms/step - accuracy: 0.9970 - loss: 0.0097 - val_accuracy: 0.9744 - val_loss: 0.1306
Epoch 24/50
329/329 ━━━━━━━━━━━━━━━━━━━━ 1s 2ms/step - accuracy: 0.9984 - loss: 0.0059 - val_accuracy: 0.9736 - val_loss: 0.1418
Epoch 25/50
329/329 ━━━━━━━━━━━━━━━━━━━━ 1s 2ms/step - accuracy: 0.9987 - loss: 0.0048 - val_accuracy: 0.9707 - val_loss: 0.1535
Epoch 26/50
329/329 ━━━━━━━━━━━━━━━━━━━━ 1s 2ms/step - accuracy: 0.9950 - loss: 0.0134 - val_accuracy: 0.9722 - val_loss: 0.1517
Epoch 27/50
329/329 ━━━━━━━━━━━━━━━━━━━━ 1s 2ms/step - accuracy: 0.9989 - loss: 0.0040 - val_accuracy: 0.9727 - val_loss: 0.1534
Epoch 28/50
329/329 ━━━━━━━━━━━━━━━━━━━━ 1s 2ms/step - accuracy: 0.9969 - loss: 0.0097 - val_accuracy: 0.9694 - val_loss: 0.1648
Epoch 29/50
329/329 ━━━━━━━━━━━━━━━━━━━━ 1s 2ms/step - accuracy: 0.9986 - loss: 0.0048 - val_accuracy: 0.9734 - val_loss: 0.1489
Epoch 30/50
329/329 ━━━━━━━━━━━━━━━━━━━━ 1s 2ms/step - accuracy: 0.9989 - loss: 0.0035 - val_accuracy: 0.9739 - val_loss: 0.1541
Epoch 31/50
329/329 ━━━━━━━━━━━━━━━━━━━━ 1s 2ms/step - accuracy: 0.9956 - loss: 0.0155 - val_accuracy: 0.9703 - val_loss: 0.1637
Epoch 32/50
329/329 ━━━━━━━━━━━━━━━━━━━━ 1s 2ms/step - accuracy: 0.9976 - loss: 0.0070 - val_accuracy: 0.9736 - val_loss: 0.1508
Epoch 33/50
329/329 ━━━━━━━━━━━━━━━━━━━━ 1s 2ms/step - accuracy: 0.9987 - loss: 0.0032 - val_accuracy: 0.9743 - val_loss: 0.1453
Epoch 34/50
329/329 ━━━━━━━━━━━━━━━━━━━━ 1s 2ms/step - accuracy: 0.9998 - loss: 9.3090e-04 - val_accuracy: 0.9761 - val_loss: 0.1458
Epoch 35/50
329/329 ━━━━━━━━━━━━━━━━━━━━ 1s 2ms/step - accuracy: 0.9999 - loss: 6.2426e-04 - val_accuracy: 0.9739 - val_loss: 0.1541
Epoch 36/50
329/329 ━━━━━━━━━━━━━━━━━━━━ 1s 2ms/step - accuracy: 1.0000 - loss: 4.3768e-04 - val_accuracy: 0.9760 - val_loss: 0.1477
Epoch 37/50
329/329 ━━━━━━━━━━━━━━━━━━━━ 1s 2ms/step - accuracy: 1.0000 - loss: 1.0332e-04 - val_accuracy: 0.9761 - val_loss: 0.1504
Epoch 38/50
329/329 ━━━━━━━━━━━━━━━━━━━━ 1s 2ms/step - accuracy: 1.0000 - loss: 7.5064e-05 - val_accuracy: 0.9758 - val_loss: 0.1514
Epoch 39/50
329/329 ━━━━━━━━━━━━━━━━━━━━ 1s 2ms/step - accuracy: 1.0000 - loss: 6.7781e-05 - val_accuracy: 0.9762 - val_loss: 0.1528
Epoch 40/50
329/329 ━━━━━━━━━━━━━━━━━━━━ 1s 2ms/step - accuracy: 1.0000 - loss: 5.3892e-05 - val_accuracy: 0.9764 - val_loss: 0.1545
Epoch 41/50
329/329 ━━━━━━━━━━━━━━━━━━━━ 1s 2ms/step - accuracy: 1.0000 - loss: 4.8135e-05 - val_accuracy: 0.9763 - val_loss: 0.1564
Epoch 42/50
329/329 ━━━━━━━━━━━━━━━━━━━━ 1s 2ms/step - accuracy: 1.0000 - loss: 3.6767e-05 - val_accuracy: 0.9762 - val_loss: 0.1588
Epoch 43/50
329/329 ━━━━━━━━━━━━━━━━━━━━ 1s 2ms/step - accuracy: 1.0000 - loss: 3.5120e-05 - val_accuracy: 0.9762 - val_loss: 0.1588
Epoch 44/50
329/329 ━━━━━━━━━━━━━━━━━━━━ 1s 2ms/step - accuracy: 1.0000 - loss: 2.9870e-05 - val_accuracy: 0.9764 - val_loss: 0.1614
Epoch 45/50
329/329 ━━━━━━━━━━━━━━━━━━━━ 1s 2ms/step - accuracy: 1.0000 - loss: 2.4976e-05 - val_accuracy: 0.9764 - val_loss: 0.1634
Epoch 46/50
329/329 ━━━━━━━━━━━━━━━━━━━━ 1s 2ms/step - accuracy: 1.0000 - loss: 2.2570e-05 - val_accuracy: 0.9764 - val_loss: 0.1647
Epoch 47/50
329/329 ━━━━━━━━━━━━━━━━━━━━ 1s 2ms/step - accuracy: 1.0000 - loss: 2.0138e-05 - val_accuracy: 0.9764 - val_loss: 0.1668
Epoch 48/50
329/329 ━━━━━━━━━━━━━━━━━━━━ 1s 2ms/step - accuracy: 1.0000 - loss: 1.7230e-05 - val_accuracy: 0.9761 - val_loss: 0.1682
Epoch 49/50
329/329 ━━━━━━━━━━━━━━━━━━━━ 1s 2ms/step - accuracy: 1.0000 - loss: 1.5470e-05 - val_accuracy: 0.9765 - val_loss: 0.1708
Epoch 50/50
329/329 ━━━━━━━━━━━━━━━━━━━━ 1s 2ms/step - accuracy: 1.0000 - loss: 1.3635e-05 - val_accuracy: 0.9765 - val_loss: 0.1719

history.history.keys()

dict_keys(['accuracy', 'loss', 'val_accuracy', 'val_loss'])

# 기록을 눈으로 보기 편하게 시각화
# history 객체에서 학습 기록을 딕셔너리 형태로 가져옴
# history.history에는 loss, accuracy 등의 지표가 epoch별로 저장되어 있음
history_dict = history.history

# 학습 손실(loss)과 검증 손실(validation loss) 데이터 추출
loss = history_dict['loss']
val_loss = history_dict['val_loss']

# 시각화를 위한 x축 데이터(epochs) 생성. 1부터 시작하여 loss 데이터 길이만큼의 범위 생성
epochs = range(1, len(loss)+1)

# 그래프를 그리기 위한 figure 생성
# figsize로 그래프 크기 지정 (가로 12, 세로 5)
fig = plt.figure(figsize=(12,5))

ax1 = fig.add_subplot(1, 2, 1) # 행 / 열 / 위치
ax1.plot(epochs, loss, color='blue', label='train_loss')
ax1.plot(epochs, val_loss, color='red', label='val_loss')

ax1.set_title('Train and Validation Loss')
ax1.set_xlabel('Epochs')
ax1.set_ylabel('Loss')
ax1.grid()
ax1.legend() 

# 학습 정확도(accuracy)와 검증 정확도(validation accuracy) 데이터 추출
accuracy = history_dict['accuracy']
val_accuracy = history_dict['val_accuracy']

ax2 = fig.add_subplot(1, 2, 2)
ax2.plot(epochs, accuracy, color='blue', label='train_accuracy')
ax2.plot(epochs, val_accuracy, color='red', label='val_accuracy')

ax2.set_title('Train and Validation accuracy')
ax2.set_xlabel('Epochs')
ax2.set_ylabel('Loss')
ax2.grid()
ax2.legend()

<matplotlib.legend.Legend at 0x2367e49c430>

모델 평가 및 예측

model.evaluate(x_test, y_test)

313/313 ━━━━━━━━━━━━━━━━━━━━ 0s 783us/step - accuracy: 0.9744 - loss: 0.1925





[0.16237415373325348, 0.9783999919891357]

y_pred = model.predict(x_test)
print(y_pred.shape)

print(y_pred[0])
print(np.round(y_pred[0],3))

313/313 ━━━━━━━━━━━━━━━━━━━━ 0s 654us/step
(10000, 10)
[1.148e-19 1.542e-18 1.598e-15 2.186e-12 3.355e-22 1.069e-22 2.931e-35
 1.000e+00 1.177e-22 1.007e-15]
[0. 0. 0. 0. 0. 0. 0. 1. 0. 0.]

arg_pred_y = np.argmax(y_pred[0])

plt.imshow(x_test[0], cmap='gray')
plt.title(f'predicted label : {arg_pred_y}')
plt.show()

• 혼동 행렬 (Confusion Matrix)

from sklearn.metrics import classification_report, confusion_matrix
import seaborn as sns
sns.set(style='white')

np.argmax(y_pred, axis=1)

array([7, 2, 1, ..., 4, 5, 6], dtype=int64)

'''
cm: 이것은 히트맵으로 표시할 데이터입니다.
cm은 일반적으로 혼동 행렬을 나타내며, 2차원 배열 형태로 데이터를 포함합니다.

annot (annotation): True로 설정될 경우, 각 셀에 데이터 값이 표시됩니다.
즉, 매트릭스의 각 요소가 그래프에 숫자 형태로 주석으로 추가되어 보다 읽기 쉬운 히트맵을 생성합니다.

fmt ('d'): 주석으로 추가된 데이터의 포맷을 지정합니다.
여기서 'd'는 정수 형식을 의미합니다. 이 옵션은 annot=True일 때 유효하며, 각 셀의 숫자를 정수 형태로 표시하도록 설정합니다.

cmap ('Blues'): 이것은 히트맵에 사용할 컬러 맵을 지정합니다.
'Blues'는 파란색 계열의 컬러 맵을 의미하며, 값이 낮은 영역은 연한 파란색, 값이 높은 영역은 진한 파란색으로 표시됩니다.
Seaborn과 Matplotlib에서 다양한 컬러 맵을 제공하며, 이를 통해 시각적으로 표현의 차이를 뚜렷하게 할 수 있습니다.
'''

plt.figure(figsize=(8,8))
cm = confusion_matrix(np.argmax(y_test, axis=1), np.argmax(y_pred, axis=1))
sns.heatmap(cm, annot=True, fmt='d', cmap='Blues')
plt.show('True Label')
plt.show()

• 분류 보고서

print(classification_report(np.argmax(y_test, axis=1), np.argmax(y_pred, axis=1)))

              precision    recall  f1-score   support

           0       0.98      0.99      0.99       980
           1       0.98      0.99      0.99      1135
           2       0.97      0.98      0.98      1032
           3       0.97      0.98      0.98      1010
           4       0.97      0.98      0.97       982
           5       0.98      0.97      0.98       892
           6       0.99      0.97      0.98       958
           7       0.98      0.97      0.98      1028
           8       0.97      0.97      0.97       974
           9       0.98      0.97      0.98      1009

    accuracy                           0.98     10000
   macro avg       0.98      0.98      0.98     10000
weighted avg       0.98      0.98      0.98     10000

모델 저장과 복원

• save()

• load_model()

• Sequencial API, 함수형 API에서는 모델의 저장 및 로드가 가능하지만 서브클래싱 방식으로는 할 수 없음

• 서브클래싱 방식은 save_weights()와 load_weights()를 이용해 모델의 파라미터만 저장 및 로드

• custom_objects 옵션에 클래스 정의하여 가능 -> models.load_model('mnist_model.h5', custom_objects={'MyMode': MyModel})

• JSON 형식

  • model.to_json() (저장)
  • tf.keras.models.model_from_json(file_path) (복원)

• YAML로 직렬화

  • model.to_yaml() (저장)
  • tf.keras.models.model_from_yaml(file_path) (복원)

model.save('mnist_model.h5')

WARNING:absl:You are saving your model as an HDF5 file via `model.save()` or `keras.saving.save_model(model)`. This file format is considered legacy. We recommend using instead the native Keras format, e.g. `model.save('my_model.keras')` or `keras.saving.save_model(model, 'my_model.keras')`. 

loaded_model = models.load_model('mnist_model.h5')
loaded_model.summary()

WARNING:absl:Compiled the loaded model, but the compiled metrics have yet to be built. `model.compile_metrics` will be empty until you train or evaluate the model.

Model: "sequential_2"

┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓
┃ Layer (type)                    ┃ Output Shape           ┃       Param # ┃
┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩
│ flatten (Flatten)               │ (None, 784)            │             0 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ dense_8 (Dense)                 │ (None, 100)            │        78,500 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ dense_9 (Dense)                 │ (None, 64)             │         6,464 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ dense_10 (Dense)                │ (None, 32)             │         2,080 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ dense_11 (Dense)                │ (None, 10)             │           330 │
└─────────────────────────────────┴────────────────────────┴───────────────┘

 Total params: 87,376 (341.32 KB)

 Trainable params: 87,374 (341.30 KB)

 Non-trainable params: 0 (0.00 B)

 Optimizer params: 2 (12.00 B)

pred_y2 = loaded_model.predict(x_test)
arg_pred_y = np.argmax(pred_y2[0])

plt.imshow(x_test[0], cmap='gray')
plt.title(f'predicted label : {arg_pred_y}')
plt.show()

313/313 ━━━━━━━━━━━━━━━━━━━━ 0s 782us/step

콜백 (Callbacks)

• 모델의 학습 과정에서 특정 지점에서 자동으로 호출되는 함수 또는 작업의 집합
• fit() 함수의 callbacks 매개변수를 사용하여 케라스가 훈련의 시작이나 끝에 호출할 객체 리스트를 지정할 수 있음
• 여러 개 사용 가능
• ModelCheckpoint
  • tf.keras.callbacks.ModelCheckpoint
  • 정기적으로 모델의 체크포인트를 저장하고, 문제가 발생할 때 복구하는데 사용
• EarlyStopping
  • tf.keras.callbacks.EarlyStopping
  • 검증 성능이 한동안 개선되지 않을 경우 학습을 중단할 때 사용
• LearningRateSchduler
  • tf.keras.callbacks.LearningRateSchduler
  • 최적화를 하는 동안 학습률(learning_rate)를 동적으로 변경할 때 사용
• TensorBoard
  • tf.keras.callbacks.TensorBoard
  • 모델의 경과를 모니터링할 때 사용

from tensorflow.keras.callbacks import ModelCheckpoint, EarlyStopping, LearningRateScheduler,TensorBoard

ModelCheckpoint

check_point_cb = ModelCheckpoint('keras_mnist_model.keras') # 저장할 model의 path 설정, 확장자h5 확인 필요
history = model.fit(x_train, y_train, epochs=10, callbacks=[check_point_cb])

Epoch 1/10
1313/1313 ━━━━━━━━━━━━━━━━━━━━ 2s 1ms/step - accuracy: 0.9882 - loss: 0.0485
Epoch 2/10
1313/1313 ━━━━━━━━━━━━━━━━━━━━ 1s 907us/step - accuracy: 0.9900 - loss: 0.0307
Epoch 3/10
1313/1313 ━━━━━━━━━━━━━━━━━━━━ 1s 1ms/step - accuracy: 0.9936 - loss: 0.0195  
Epoch 4/10
1313/1313 ━━━━━━━━━━━━━━━━━━━━ 1s 1ms/step - accuracy: 0.9922 - loss: 0.0239
Epoch 5/10
1313/1313 ━━━━━━━━━━━━━━━━━━━━ 1s 923us/step - accuracy: 0.9935 - loss: 0.0188
Epoch 6/10
1313/1313 ━━━━━━━━━━━━━━━━━━━━ 1s 977us/step - accuracy: 0.9951 - loss: 0.0148
Epoch 7/10
1313/1313 ━━━━━━━━━━━━━━━━━━━━ 1s 913us/step - accuracy: 0.9949 - loss: 0.0162
Epoch 8/10
1313/1313 ━━━━━━━━━━━━━━━━━━━━ 1s 916us/step - accuracy: 0.9959 - loss: 0.0139
Epoch 9/10
1313/1313 ━━━━━━━━━━━━━━━━━━━━ 1s 927us/step - accuracy: 0.9953 - loss: 0.0141
Epoch 10/10
1313/1313 ━━━━━━━━━━━━━━━━━━━━ 1s 948us/step - accuracy: 0.9941 - loss: 0.0180

최상의 모델만을 저장: save_best_only=True

check_point_cb = ModelCheckpoint('keras_mnist_model.keras', save_best_only=True) # 저장할 model의 path 설정, 확장자h5 확인 필요
history = model.fit(x_train, y_train, epochs=10,
                    validation_data=(x_val, y_val),
                    callbacks=[check_point_cb])

Epoch 1/10
1313/1313 ━━━━━━━━━━━━━━━━━━━━ 2s 1ms/step - accuracy: 0.9973 - loss: 0.0087 - val_accuracy: 0.9727 - val_loss: 0.1711
Epoch 2/10
1313/1313 ━━━━━━━━━━━━━━━━━━━━ 2s 1ms/step - accuracy: 0.9963 - loss: 0.0102 - val_accuracy: 0.9758 - val_loss: 0.1526
Epoch 3/10
1313/1313 ━━━━━━━━━━━━━━━━━━━━ 2s 1ms/step - accuracy: 0.9987 - loss: 0.0056 - val_accuracy: 0.9706 - val_loss: 0.1943
Epoch 4/10
1313/1313 ━━━━━━━━━━━━━━━━━━━━ 2s 1ms/step - accuracy: 0.9968 - loss: 0.0089 - val_accuracy: 0.9717 - val_loss: 0.2081
Epoch 5/10
1313/1313 ━━━━━━━━━━━━━━━━━━━━ 2s 1ms/step - accuracy: 0.9974 - loss: 0.0082 - val_accuracy: 0.9734 - val_loss: 0.1849
Epoch 6/10
1313/1313 ━━━━━━━━━━━━━━━━━━━━ 2s 1ms/step - accuracy: 0.9968 - loss: 0.0107 - val_accuracy: 0.9706 - val_loss: 0.2134
Epoch 7/10
1313/1313 ━━━━━━━━━━━━━━━━━━━━ 2s 1ms/step - accuracy: 0.9960 - loss: 0.0132 - val_accuracy: 0.9694 - val_loss: 0.2081
Epoch 8/10
1313/1313 ━━━━━━━━━━━━━━━━━━━━ 2s 1ms/step - accuracy: 0.9970 - loss: 0.0087 - val_accuracy: 0.9751 - val_loss: 0.1717
Epoch 9/10
1313/1313 ━━━━━━━━━━━━━━━━━━━━ 2s 1ms/step - accuracy: 0.9976 - loss: 0.0085 - val_accuracy: 0.9724 - val_loss: 0.1924
Epoch 10/10
1313/1313 ━━━━━━━━━━━━━━━━━━━━ 2s 1ms/step - accuracy: 0.9979 - loss: 0.0067 - val_accuracy: 0.9726 - val_loss: 0.1963

EarlyStopping

• 일정 patience 동안 검증 세트에 대한 점수가 오르지 않으면 학습을 멈춤
• 모델이 향상되지 않으면 학습이 자동으로 중지되므로, epochs 숫자를 크게 해도 무방
• 학습이 끝난 후의 최상의 가중치를 복원하기 때문에 모델을 따로 복원할 필요없음

check_point_cb = ModelCheckpoint('keras_mnist_model.keras', save_best_only=True)
early_stopping_cb = EarlyStopping(patience=3, monitor='val_loss', restore_best_weights=True)
history = model.fit(x_train, y_train, epochs=10,
                    validation_data=(x_val, y_val),
                    callbacks=[check_point_cb])

''' 
restore_best_weights=True 의 의미:
True 설정: 훈련이 조기 종료될 때, 가장 좋은 성능을 보였던 시점의 모델 가중치를 자동으로 복원합니다.
즉, monitor 파라미터로 지정된 메트릭 (예: val_loss)을 기준으로 최소/최대 값을 달성했을 때의 가중치로 모델을 복원합니다.
이는 훈련이 더 이상 성능 개선을 이루지 못하고 종료되더라도, 가장 좋은 상태의 모델을 사용할 수 있도록 보장합니다.

False 설정: 훈련이 종료될 때 현재의 가중치를 그대로 유지합니다.
이 경우, 성능이 가장 좋았던 시점의 가중치로 복원되지 않고,
훈련 중단 시점의 가중치가 모델에 남게 됩니다.
'''

Epoch 1/10
1313/1313 ━━━━━━━━━━━━━━━━━━━━ 2s 2ms/step - accuracy: 0.9967 - loss: 0.0125 - val_accuracy: 0.9726 - val_loss: 0.1946
Epoch 2/10
1313/1313 ━━━━━━━━━━━━━━━━━━━━ 2s 2ms/step - accuracy: 0.9975 - loss: 0.0070 - val_accuracy: 0.9699 - val_loss: 0.2254
Epoch 3/10
1313/1313 ━━━━━━━━━━━━━━━━━━━━ 2s 2ms/step - accuracy: 0.9965 - loss: 0.0126 - val_accuracy: 0.9729 - val_loss: 0.1826
Epoch 4/10
1313/1313 ━━━━━━━━━━━━━━━━━━━━ 2s 1ms/step - accuracy: 0.9989 - loss: 0.0045 - val_accuracy: 0.9737 - val_loss: 0.1836
Epoch 5/10
1313/1313 ━━━━━━━━━━━━━━━━━━━━ 2s 1ms/step - accuracy: 0.9985 - loss: 0.0056 - val_accuracy: 0.9680 - val_loss: 0.2198
Epoch 6/10
1313/1313 ━━━━━━━━━━━━━━━━━━━━ 2s 1ms/step - accuracy: 0.9964 - loss: 0.0115 - val_accuracy: 0.9739 - val_loss: 0.1783
Epoch 7/10
1313/1313 ━━━━━━━━━━━━━━━━━━━━ 2s 1ms/step - accuracy: 0.9982 - loss: 0.0071 - val_accuracy: 0.9745 - val_loss: 0.1892
Epoch 8/10
1313/1313 ━━━━━━━━━━━━━━━━━━━━ 2s 1ms/step - accuracy: 0.9989 - loss: 0.0047 - val_accuracy: 0.9722 - val_loss: 0.1979
Epoch 9/10
1313/1313 ━━━━━━━━━━━━━━━━━━━━ 2s 1ms/step - accuracy: 0.9969 - loss: 0.0110 - val_accuracy: 0.9741 - val_loss: 0.1942
Epoch 10/10
1313/1313 ━━━━━━━━━━━━━━━━━━━━ 2s 1ms/step - accuracy: 0.9971 - loss: 0.0087 - val_accuracy: 0.9751 - val_loss: 0.2046





' \nrestore_best_weights=True 의 의미:\nTrue 설정: 훈련이 조기 종료될 때, 가장 좋은 성능을 보였던 시점의 모델 가중치를 자동으로 복원합니다.\n즉, monitor 파라미터로 지정된 메트릭 (예: val_loss)을 기준으로 최소/최대 값을 달성했을 때의 가중치로 모델을 복원합니다.\n이는 훈련이 더 이상 성능 개선을 이루지 못하고 종료되더라도, 가장 좋은 상태의 모델을 사용할 수 있도록 보장합니다.\n\nFalse 설정: 훈련이 종료될 때 현재의 가중치를 그대로 유지합니다.\n이 경우, 성능이 가장 좋았던 시점의 가중치로 복원되지 않고,\n훈련 중단 시점의 가중치가 모델에 남게 됩니다.\n'

LearningRateScheduler

• 학습 중에 학습률(learning rate)을 변경시키기 위해 사용

def scheduler(epoch, learning_rate):
    if epoch < 10:
        return learning_rate
    else:
        print(type(learning_rate * tf.math.exp(-0.1)))
        return learning_rate * 0.95

round(model.optimizer.learning_rate.numpy(),5)

0.001

lr_scheduler_cb = LearningRateScheduler(scheduler)

history = model.fit(x_train, y_train, epochs=15,
                    callbacks=[lr_scheduler_cb])

Epoch 1/15
1313/1313 ━━━━━━━━━━━━━━━━━━━━ 1s 924us/step - accuracy: 0.9987 - loss: 0.0049 - learning_rate: 0.0010
Epoch 2/15
1313/1313 ━━━━━━━━━━━━━━━━━━━━ 1s 890us/step - accuracy: 0.9992 - loss: 0.0034 - learning_rate: 0.0010
Epoch 3/15
1313/1313 ━━━━━━━━━━━━━━━━━━━━ 1s 950us/step - accuracy: 0.9993 - loss: 0.0031 - learning_rate: 0.0010
Epoch 4/15
1313/1313 ━━━━━━━━━━━━━━━━━━━━ 1s 913us/step - accuracy: 0.9980 - loss: 0.0096 - learning_rate: 0.0010
Epoch 5/15
1313/1313 ━━━━━━━━━━━━━━━━━━━━ 1s 917us/step - accuracy: 0.9990 - loss: 0.0036 - learning_rate: 0.0010
Epoch 6/15
1313/1313 ━━━━━━━━━━━━━━━━━━━━ 1s 910us/step - accuracy: 0.9987 - loss: 0.0046 - learning_rate: 0.0010
Epoch 7/15
1313/1313 ━━━━━━━━━━━━━━━━━━━━ 1s 904us/step - accuracy: 0.9986 - loss: 0.0063 - learning_rate: 0.0010
Epoch 8/15
1313/1313 ━━━━━━━━━━━━━━━━━━━━ 1s 935us/step - accuracy: 0.9989 - loss: 0.0037 - learning_rate: 0.0010
Epoch 9/15
1313/1313 ━━━━━━━━━━━━━━━━━━━━ 1s 958us/step - accuracy: 0.9986 - loss: 0.0059 - learning_rate: 0.0010
Epoch 10/15
1313/1313 ━━━━━━━━━━━━━━━━━━━━ 1s 904us/step - accuracy: 0.9988 - loss: 0.0040 - learning_rate: 0.0010
<class 'tensorflow.python.framework.ops.EagerTensor'>
Epoch 11/15
1313/1313 ━━━━━━━━━━━━━━━━━━━━ 1s 905us/step - accuracy: 0.9984 - loss: 0.0053 - learning_rate: 9.5000e-04
<class 'tensorflow.python.framework.ops.EagerTensor'>
Epoch 12/15
1313/1313 ━━━━━━━━━━━━━━━━━━━━ 1s 908us/step - accuracy: 0.9988 - loss: 0.0041 - learning_rate: 9.0250e-04
<class 'tensorflow.python.framework.ops.EagerTensor'>
Epoch 13/15
1313/1313 ━━━━━━━━━━━━━━━━━━━━ 1s 907us/step - accuracy: 0.9998 - loss: 0.0010 - learning_rate: 8.5737e-04
<class 'tensorflow.python.framework.ops.EagerTensor'>
Epoch 14/15
1313/1313 ━━━━━━━━━━━━━━━━━━━━ 1s 905us/step - accuracy: 0.9989 - loss: 0.0049 - learning_rate: 8.1451e-04
<class 'tensorflow.python.framework.ops.EagerTensor'>
Epoch 15/15
1313/1313 ━━━━━━━━━━━━━━━━━━━━ 1s 930us/step - accuracy: 0.9994 - loss: 0.0016 - learning_rate: 7.7378e-04

round(model.optimizer.learning_rate.numpy(),5)

0.00077

Tensorboard

• TensorFlow와 Keras에서 사용하는 모델의 훈련 과정을 모니터링하고 디버깅하는 데 유용한 시각화 도구
• 텐서보드를 이용하여 학습과정 모니터링
• 텐서보드를 사용하기 위해 logs 폴더를 만들고, 학습이 진행되는 동안 로그 파일을 생성

----- 텐서보드 옵션-----

• histogram_freq: 이 옵션은 몇 번째 에포크마다 히스토그램을 기록할지 설정
• write_graph: 이 설정은 True로 설정되면, 훈련 중에 모델 구조 그래프를 기록하여 TensorBoard에서 볼 수 있습니다.
• 그래프는 모델의 구조를 시각화해줍니다. 이는 모델의 구조를 이해하거나 문제를 진단하는 데 도움을 줄 수 있습니다.
• write_images: True일 경우 에포크마다 가중치를 이미지로 기록. 가중치가 어떻게 변화하는지 시각적으로 분석할 수 있는 기능

log_dir = '\\logs' # 파일 경로 한글 없게
tensor_board_cb = [TensorBoard(log_dir=log_dir, histogram_freq=1, write_graph=True, write_images=True)]
history = model.fit(x_train, y_train, epochs=30,
                    validation_data=(x_val, y_val),
                    callbacks=tensor_board_cb)

Epoch 1/30
1313/1313 ━━━━━━━━━━━━━━━━━━━━ 2s 2ms/step - accuracy: 0.9997 - loss: 0.0014 - val_accuracy: 0.9769 - val_loss: 0.2594
Epoch 2/30
1313/1313 ━━━━━━━━━━━━━━━━━━━━ 2s 2ms/step - accuracy: 0.9994 - loss: 0.0021 - val_accuracy: 0.9754 - val_loss: 0.2795
Epoch 3/30
1313/1313 ━━━━━━━━━━━━━━━━━━━━ 2s 2ms/step - accuracy: 0.9997 - loss: 9.3488e-04 - val_accuracy: 0.9766 - val_loss: 0.3055
Epoch 4/30
1313/1313 ━━━━━━━━━━━━━━━━━━━━ 2s 2ms/step - accuracy: 0.9996 - loss: 0.0011 - val_accuracy: 0.9751 - val_loss: 0.3416
Epoch 5/30
1313/1313 ━━━━━━━━━━━━━━━━━━━━ 2s 2ms/step - accuracy: 0.9986 - loss: 0.0056 - val_accuracy: 0.9769 - val_loss: 0.2949
Epoch 6/30
1313/1313 ━━━━━━━━━━━━━━━━━━━━ 3s 2ms/step - accuracy: 0.9994 - loss: 0.0019 - val_accuracy: 0.9743 - val_loss: 0.3046
Epoch 7/30
1313/1313 ━━━━━━━━━━━━━━━━━━━━ 3s 2ms/step - accuracy: 0.9990 - loss: 0.0041 - val_accuracy: 0.9749 - val_loss: 0.2963
Epoch 8/30
1313/1313 ━━━━━━━━━━━━━━━━━━━━ 3s 2ms/step - accuracy: 0.9994 - loss: 0.0030 - val_accuracy: 0.9767 - val_loss: 0.2759
Epoch 9/30
1313/1313 ━━━━━━━━━━━━━━━━━━━━ 3s 2ms/step - accuracy: 0.9995 - loss: 0.0023 - val_accuracy: 0.9747 - val_loss: 0.3031
Epoch 10/30
1313/1313 ━━━━━━━━━━━━━━━━━━━━ 3s 2ms/step - accuracy: 0.9991 - loss: 0.0025 - val_accuracy: 0.9769 - val_loss: 0.2728
Epoch 11/30
1313/1313 ━━━━━━━━━━━━━━━━━━━━ 2s 2ms/step - accuracy: 0.9996 - loss: 0.0023 - val_accuracy: 0.9772 - val_loss: 0.2714
Epoch 12/30
1313/1313 ━━━━━━━━━━━━━━━━━━━━ 2s 2ms/step - accuracy: 0.9996 - loss: 0.0013 - val_accuracy: 0.9753 - val_loss: 0.2902
Epoch 13/30
1313/1313 ━━━━━━━━━━━━━━━━━━━━ 2s 2ms/step - accuracy: 0.9996 - loss: 0.0019 - val_accuracy: 0.9763 - val_loss: 0.2811
Epoch 14/30
1313/1313 ━━━━━━━━━━━━━━━━━━━━ 2s 2ms/step - accuracy: 0.9994 - loss: 0.0030 - val_accuracy: 0.9759 - val_loss: 0.2879
Epoch 15/30
1313/1313 ━━━━━━━━━━━━━━━━━━━━ 2s 2ms/step - accuracy: 0.9995 - loss: 0.0021 - val_accuracy: 0.9729 - val_loss: 0.3165
Epoch 16/30
1313/1313 ━━━━━━━━━━━━━━━━━━━━ 2s 2ms/step - accuracy: 0.9996 - loss: 0.0010 - val_accuracy: 0.9766 - val_loss: 0.3044
Epoch 17/30
1313/1313 ━━━━━━━━━━━━━━━━━━━━ 2s 2ms/step - accuracy: 0.9996 - loss: 0.0015 - val_accuracy: 0.9745 - val_loss: 0.3361
Epoch 18/30
1313/1313 ━━━━━━━━━━━━━━━━━━━━ 2s 2ms/step - accuracy: 0.9993 - loss: 0.0042 - val_accuracy: 0.9748 - val_loss: 0.3142
Epoch 19/30
1313/1313 ━━━━━━━━━━━━━━━━━━━━ 2s 2ms/step - accuracy: 0.9996 - loss: 0.0011 - val_accuracy: 0.9752 - val_loss: 0.3107
Epoch 20/30
1313/1313 ━━━━━━━━━━━━━━━━━━━━ 2s 2ms/step - accuracy: 0.9995 - loss: 0.0017 - val_accuracy: 0.9757 - val_loss: 0.3031
Epoch 21/30
1313/1313 ━━━━━━━━━━━━━━━━━━━━ 2s 2ms/step - accuracy: 0.9994 - loss: 0.0019 - val_accuracy: 0.9763 - val_loss: 0.3059
Epoch 22/30
1313/1313 ━━━━━━━━━━━━━━━━━━━━ 2s 2ms/step - accuracy: 0.9999 - loss: 5.5803e-04 - val_accuracy: 0.9746 - val_loss: 0.3209
Epoch 23/30
1313/1313 ━━━━━━━━━━━━━━━━━━━━ 2s 2ms/step - accuracy: 0.9991 - loss: 0.0041 - val_accuracy: 0.9753 - val_loss: 0.3280
Epoch 24/30
1313/1313 ━━━━━━━━━━━━━━━━━━━━ 2s 2ms/step - accuracy: 0.9998 - loss: 8.1612e-04 - val_accuracy: 0.9769 - val_loss: 0.3084
Epoch 25/30
1313/1313 ━━━━━━━━━━━━━━━━━━━━ 2s 2ms/step - accuracy: 0.9992 - loss: 0.0033 - val_accuracy: 0.9754 - val_loss: 0.3182
Epoch 26/30
1313/1313 ━━━━━━━━━━━━━━━━━━━━ 2s 2ms/step - accuracy: 0.9996 - loss: 0.0017 - val_accuracy: 0.9760 - val_loss: 0.3251
Epoch 27/30
1313/1313 ━━━━━━━━━━━━━━━━━━━━ 2s 2ms/step - accuracy: 0.9996 - loss: 0.0015 - val_accuracy: 0.9763 - val_loss: 0.3228
Epoch 28/30
1313/1313 ━━━━━━━━━━━━━━━━━━━━ 2s 2ms/step - accuracy: 0.9993 - loss: 0.0030 - val_accuracy: 0.9762 - val_loss: 0.3092
Epoch 29/30
1313/1313 ━━━━━━━━━━━━━━━━━━━━ 2s 2ms/step - accuracy: 0.9996 - loss: 8.6534e-04 - val_accuracy: 0.9768 - val_loss: 0.3188
Epoch 30/30
1313/1313 ━━━━━━━━━━━━━━━━━━━━ 2s 2ms/step - accuracy: 0.9995 - loss: 0.0015 - val_accuracy: 0.9757 - val_loss: 0.3248

%load_ext tensorboard # 코랩의 경우
%tensorboard --logdir {log_dir}

• 텐서보드 load가 안된다면 port 번호를 바꿔서 실행 %tensorboard --logdir {log_dir} port 8000

# 로컬
!tensorboard --logdir="c:\\Users\\rlaal\\OneDrive\\logs" --port=8000

2024-10-21 02:31:21.254627: I tensorflow/core/util/port.cc:153] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.
2024-10-21 02:31:22.096791: I tensorflow/core/util/port.cc:153] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.
usage: tensorboard [-h] [--helpfull] [--logdir PATH] [--logdir_spec PATH_SPEC]
                   [--host ADDR] [--bind_all] [--port PORT]
                   [--reuse_port BOOL] [--load_fast {false,auto,true}]
                   [--extra_data_server_flags EXTRA_DATA_SERVER_FLAGS]
                   [--grpc_creds_type {local,ssl,ssl_dev}]
                   [--grpc_data_provider PORT] [--purge_orphaned_data BOOL]
                   [--db URI] [--db_import] [--inspect] [--version_tb]
                   [--tag TAG] [--event_file PATH] [--path_prefix PATH]
                   [--window_title TEXT] [--max_reload_threads COUNT]
                   [--reload_interval SECONDS] [--reload_task TYPE]
                   [--reload_multifile BOOL]
                   [--reload_multifile_inactive_secs SECONDS]
                   [--generic_data TYPE]
                   [--samples_per_plugin SAMPLES_PER_PLUGIN]
                   [--detect_file_replacement BOOL]
                   {serve} ...
tensorboard: error: argument {serve}: invalid choice: 'c:\\\\Users\\\\rlaal\\\\OneDrive\\\\logs' (choose from 'serve')

딥러닝 학습 기술

IMDB 딥러닝 모델 예제

• 영화 사이트 IMDB의 리뷰 데이터
• 텍스트 분류, 감성 분류를 위해 자주 사용하는 데이터
• 리뷰 텍스트와 리뷰가 긍정인 경우 1을 부정인 경우 0으로 표시한 레이블
• 케라스에서는 IMDB 영화 리뷰 데이터를 imdb.load_data() 함수를 통해 다운로드 가능

from tensorflow.keras.datasets import imdb
import numpy as np

# num_words=10000 데이터셋에서 가장 빈번하게 등장하는 상위 10,000개의 단어만을 포함하도록 제한
(train_data, train_labels), (test_data, test_labels) = imdb.load_data(num_words=10000) 

# train_data의 숫자 자리를 1, 아닌곳 0

def vectorize_seq(seqs, dim=10000):
    '''
    각 리뷰(단어의 시퀀스)를 원-핫 인코딩 방식으로 벡터화합니다.
    원-핫 인코딩은 단어의 인덱스에 해당하는 위치의 값을 1로 설정하고,
    나머지는 0으로 설정하는 벡터 표현 방법입니다.
    '''

    results = np.zeros((len(seqs), dim))
    for i, seq in enumerate(seqs): 
        results[i,seq] = 1
    return results

x_train = vectorize_seq(train_data)
x_test= vectorize_seq(test_data)

y_train = np.asarray(train_labels).astype('float32')
y_test = np.asarray(test_labels).astype('float32')

import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense

model = Sequential([
    Dense(16, input_shape = (10000,), name = 'input'),
    Dense(16, activation='relu', name = 'hidden'),
    Dense(1, activation='sigmoid',name = 'output')])

model.compile(optimizer='adam',
            loss = 'binary_crossentropy',
            metrics=['acc'])
model.summary()

Model: "sequential_1"

┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓
┃ Layer (type)                    ┃ Output Shape           ┃       Param # ┃
┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩
│ input (Dense)                   │ (None, 16)             │       160,016 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ hidden (Dense)                  │ (None, 16)             │           272 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ output (Dense)                  │ (None, 1)              │            17 │
└─────────────────────────────────┴────────────────────────┴───────────────┘

 Total params: 160,305 (626.19 KB)

 Trainable params: 160,305 (626.19 KB)

 Non-trainable params: 0 (0.00 B)

model.optimizer.learning_rate = 0.0001
model_hist = model.fit(x_train, y_train,
                       epochs=20,
                       batch_size = 64,
                       validation_data=(x_test, y_test) )

Epoch 1/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 8s 17ms/step - acc: 0.6973 - loss: 0.6106 - val_acc: 0.8600 - val_loss: 0.3992
Epoch 2/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 1s 4ms/step - acc: 0.8852 - loss: 0.3409 - val_acc: 0.8816 - val_loss: 0.3086
Epoch 3/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 2s 4ms/step - acc: 0.9185 - loss: 0.2442 - val_acc: 0.8879 - val_loss: 0.2833
Epoch 4/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 2s 4ms/step - acc: 0.9336 - loss: 0.2010 - val_acc: 0.8892 - val_loss: 0.2772
Epoch 5/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 1s 3ms/step - acc: 0.9405 - loss: 0.1782 - val_acc: 0.8861 - val_loss: 0.2810
Epoch 6/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 1s 3ms/step - acc: 0.9466 - loss: 0.1590 - val_acc: 0.8853 - val_loss: 0.2882
Epoch 7/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 1s 3ms/step - acc: 0.9571 - loss: 0.1382 - val_acc: 0.8826 - val_loss: 0.2999
Epoch 8/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 1s 3ms/step - acc: 0.9631 - loss: 0.1204 - val_acc: 0.8775 - val_loss: 0.3185
Epoch 9/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 1s 3ms/step - acc: 0.9664 - loss: 0.1108 - val_acc: 0.8765 - val_loss: 0.3298
Epoch 10/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 1s 3ms/step - acc: 0.9718 - loss: 0.0977 - val_acc: 0.8732 - val_loss: 0.3488
Epoch 11/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 1s 3ms/step - acc: 0.9734 - loss: 0.0899 - val_acc: 0.8700 - val_loss: 0.3711
Epoch 12/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 1s 3ms/step - acc: 0.9774 - loss: 0.0808 - val_acc: 0.8696 - val_loss: 0.3875
Epoch 13/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 1s 3ms/step - acc: 0.9797 - loss: 0.0764 - val_acc: 0.8674 - val_loss: 0.4102
Epoch 14/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 1s 3ms/step - acc: 0.9828 - loss: 0.0676 - val_acc: 0.8636 - val_loss: 0.4400
Epoch 15/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 1s 3ms/step - acc: 0.9866 - loss: 0.0575 - val_acc: 0.8632 - val_loss: 0.4614
Epoch 16/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 1s 3ms/step - acc: 0.9878 - loss: 0.0554 - val_acc: 0.8611 - val_loss: 0.4892
Epoch 17/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 1s 3ms/step - acc: 0.9905 - loss: 0.0469 - val_acc: 0.8594 - val_loss: 0.5170
Epoch 18/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 1s 3ms/step - acc: 0.9923 - loss: 0.0411 - val_acc: 0.8571 - val_loss: 0.5487
Epoch 19/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 1s 3ms/step - acc: 0.9936 - loss: 0.0364 - val_acc: 0.8562 - val_loss: 0.5806
Epoch 20/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 1s 3ms/step - acc: 0.9945 - loss: 0.0331 - val_acc: 0.8543 - val_loss: 0.6128

import matplotlib.pyplot as plt

epochs = range(1,21)
model_val_loss = model_hist.history['val_loss']

plt.plot(epochs, model_val_loss, 'r+', label='Model')
plt.xlabel('Epochs')
plt.ylabel('Validation_Loss')
plt.legend()
plt.grid()
plt.show()

과소적합(Underfitting) / 과대적합(Overfitting)

과소적합 (Underfitting)

• 학습 데이터를 충분히 학습하지 않아 성능이 매우 안 좋은 경우
• 모델이 지나치게 단순한 경우
• 해결 방안
  • 충분한 학습 데이터 수집
  • 보다 더 복잡한 모델 사용
  • 에폭수(epochs)를 늘려 충분히 학습

과대적합 (Overfitting)

• 모델이 학습 데이터에 지나치게 맞추어진 상태
• 새로운 데이터에서는 성능 저하
• 데이터에는 잡음이나 오류가 포함
• 학습 데이터가 매우 적을 경우
• 모델이 지나치게 복잡한 경우
• 학습 횟수가 매우 많을 경우
• 해결방안
  • 다양한 학습 데이터 수집 및 학습
  • 모델 단순화: 파라미터가 적은 모델을 선택하거나, 학습 데이터의 특성 수를 줄임
  • 정규화(Regularization)을 통한 규칙 단순화
  • 적정한 하이퍼 파라미터 찾기

과대적합(overfitting)과 과소적합(underfitting) 방지 방법

• 모델의 크기 축소
• 가중치 초기화(Weight Initializer)
• 옵티마이저(Optimizer)
• 배치 정규화(Batch Normalization)
• 규제화(Regularization)
• 드롭아웃(Dropout)

모델 크기 조절

• 가장 단순한 방법
• 모델의 크기를 줄인다는 것은 학습 파라미터의 수를 줄이는 것

모델 크기 감소

model_s = Sequential([
    Dense(7, input_shape = (10000,), name = 'input'),
    Dense(7, activation='relu', name = 'hidden'),
    Dense(1, activation='sigmoid',name = 'output')])

model_s.compile(optimizer='adam',
            loss = 'binary_crossentropy',
            metrics=['acc'])
model_s.summary()

c:\Users\rlaal\anaconda3\envs\py39\lib\site-packages\keras\src\layers\core\dense.py:87: UserWarning: Do not pass an `input_shape`/`input_dim` argument to a layer. When using Sequential models, prefer using an `Input(shape)` object as the first layer in the model instead.
  super().__init__(activity_regularizer=activity_regularizer, **kwargs)

Model: "sequential_2"

┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓
┃ Layer (type)                    ┃ Output Shape           ┃       Param # ┃
┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩
│ input (Dense)                   │ (None, 7)              │        70,007 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ hidden (Dense)                  │ (None, 7)              │            56 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ output (Dense)                  │ (None, 1)              │             8 │
└─────────────────────────────────┴────────────────────────┴───────────────┘

 Total params: 70,071 (273.71 KB)

 Trainable params: 70,071 (273.71 KB)

 Non-trainable params: 0 (0.00 B)

model_s.optimizer.learning_rate = 0.0001
model_s_hist = model_s.fit(x_train, y_train,
                       epochs=20,
                       batch_size = 64,
                       validation_data=(x_test, y_test) )

Epoch 1/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 3s 6ms/step - acc: 0.6636 - loss: 0.6506 - val_acc: 0.8339 - val_loss: 0.5109
Epoch 2/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 1s 3ms/step - acc: 0.8666 - loss: 0.4570 - val_acc: 0.8669 - val_loss: 0.3952
Epoch 3/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 1s 3ms/step - acc: 0.8919 - loss: 0.3462 - val_acc: 0.8784 - val_loss: 0.3369
Epoch 4/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 1s 3ms/step - acc: 0.9083 - loss: 0.2832 - val_acc: 0.8838 - val_loss: 0.3073
Epoch 5/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 1s 3ms/step - acc: 0.9148 - loss: 0.2512 - val_acc: 0.8876 - val_loss: 0.2901
Epoch 6/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 1s 3ms/step - acc: 0.9226 - loss: 0.2241 - val_acc: 0.8885 - val_loss: 0.2828
Epoch 7/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 1s 3ms/step - acc: 0.9316 - loss: 0.1982 - val_acc: 0.8888 - val_loss: 0.2789
Epoch 8/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 1s 3ms/step - acc: 0.9339 - loss: 0.1896 - val_acc: 0.8885 - val_loss: 0.2776
Epoch 9/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 1s 3ms/step - acc: 0.9437 - loss: 0.1713 - val_acc: 0.8870 - val_loss: 0.2807
Epoch 10/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 1s 3ms/step - acc: 0.9480 - loss: 0.1582 - val_acc: 0.8874 - val_loss: 0.2831
Epoch 11/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 1s 3ms/step - acc: 0.9535 - loss: 0.1460 - val_acc: 0.8854 - val_loss: 0.2877
Epoch 12/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 1s 3ms/step - acc: 0.9565 - loss: 0.1368 - val_acc: 0.8852 - val_loss: 0.2941
Epoch 13/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 1s 3ms/step - acc: 0.9613 - loss: 0.1268 - val_acc: 0.8825 - val_loss: 0.3006
Epoch 14/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 1s 2ms/step - acc: 0.9605 - loss: 0.1250 - val_acc: 0.8816 - val_loss: 0.3085
Epoch 15/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 1s 3ms/step - acc: 0.9638 - loss: 0.1143 - val_acc: 0.8802 - val_loss: 0.3166
Epoch 16/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 1s 2ms/step - acc: 0.9685 - loss: 0.1068 - val_acc: 0.8795 - val_loss: 0.3252
Epoch 17/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 1s 2ms/step - acc: 0.9701 - loss: 0.1016 - val_acc: 0.8770 - val_loss: 0.3356
Epoch 18/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 1s 2ms/step - acc: 0.9719 - loss: 0.0960 - val_acc: 0.8753 - val_loss: 0.3463
Epoch 19/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 1s 2ms/step - acc: 0.9731 - loss: 0.0914 - val_acc: 0.8739 - val_loss: 0.3575
Epoch 20/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 1s 2ms/step - acc: 0.9760 - loss: 0.0839 - val_acc: 0.8713 - val_loss: 0.3718

import matplotlib.pyplot as plt

epochs = range(1,21)
model_s_val_loss = model_s_hist.history['val_loss']

plt.plot(epochs, model_val_loss, 'r+', label='Model')
plt.plot(epochs, model_s_val_loss, 'bo', label='Model(small)')
plt.xlabel('Epochs')
plt.ylabel('Validation_Loss')
plt.legend()
plt.grid()
plt.show()

모델 크기 증가

model_b = Sequential([
    Dense(128, input_shape = (10000,), name = 'input'),
    Dense(128, activation='relu', name = 'hidden'),
    Dense(1, activation='sigmoid',name = 'output')])

model_b.compile(optimizer='adam',
            loss = 'binary_crossentropy',
            metrics=['acc'])
model_b.summary()

Model: "sequential_3"

┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓
┃ Layer (type)                    ┃ Output Shape           ┃       Param # ┃
┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩
│ input (Dense)                   │ (None, 128)            │     1,280,128 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ hidden (Dense)                  │ (None, 128)            │        16,512 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ output (Dense)                  │ (None, 1)              │           129 │
└─────────────────────────────────┴────────────────────────┴───────────────┘

 Total params: 1,296,769 (4.95 MB)

 Trainable params: 1,296,769 (4.95 MB)

 Non-trainable params: 0 (0.00 B)

model_b.optimizer.learning_rate = 0.0001
model_b_hist = model_b.fit(x_train, y_train,
                       epochs=20,
                       batch_size = 64,
                       validation_data=(x_test, y_test) )

Epoch 1/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 7s 15ms/step - acc: 0.7663 - loss: 0.5186 - val_acc: 0.8875 - val_loss: 0.2858
Epoch 2/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 5s 13ms/step - acc: 0.9253 - loss: 0.2100 - val_acc: 0.8857 - val_loss: 0.2887
Epoch 3/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 5s 13ms/step - acc: 0.9443 - loss: 0.1578 - val_acc: 0.8791 - val_loss: 0.3134
Epoch 4/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 5s 13ms/step - acc: 0.9605 - loss: 0.1205 - val_acc: 0.8696 - val_loss: 0.3626
Epoch 5/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 5s 13ms/step - acc: 0.9664 - loss: 0.1010 - val_acc: 0.8686 - val_loss: 0.3954
Epoch 6/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 5s 12ms/step - acc: 0.9749 - loss: 0.0801 - val_acc: 0.8652 - val_loss: 0.4453
Epoch 7/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 5s 12ms/step - acc: 0.9808 - loss: 0.0698 - val_acc: 0.8593 - val_loss: 0.5088
Epoch 8/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 5s 13ms/step - acc: 0.9854 - loss: 0.0536 - val_acc: 0.8549 - val_loss: 0.5712
Epoch 9/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 5s 13ms/step - acc: 0.9890 - loss: 0.0431 - val_acc: 0.8505 - val_loss: 0.6445
Epoch 10/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 5s 13ms/step - acc: 0.9900 - loss: 0.0380 - val_acc: 0.8500 - val_loss: 0.7081
Epoch 11/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 5s 13ms/step - acc: 0.9927 - loss: 0.0300 - val_acc: 0.8483 - val_loss: 0.7733
Epoch 12/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 5s 12ms/step - acc: 0.9953 - loss: 0.0227 - val_acc: 0.8440 - val_loss: 0.8642
Epoch 13/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 5s 12ms/step - acc: 0.9950 - loss: 0.0201 - val_acc: 0.8456 - val_loss: 0.9303
Epoch 14/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 5s 12ms/step - acc: 0.9964 - loss: 0.0167 - val_acc: 0.8416 - val_loss: 1.0244
Epoch 15/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 5s 13ms/step - acc: 0.9971 - loss: 0.0140 - val_acc: 0.8430 - val_loss: 1.0881
Epoch 16/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 5s 13ms/step - acc: 0.9954 - loss: 0.0176 - val_acc: 0.8412 - val_loss: 1.1498
Epoch 17/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 5s 13ms/step - acc: 0.9922 - loss: 0.0227 - val_acc: 0.8419 - val_loss: 1.1970
Epoch 18/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 5s 12ms/step - acc: 0.9954 - loss: 0.0151 - val_acc: 0.8419 - val_loss: 1.2428
Epoch 19/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 5s 12ms/step - acc: 0.9986 - loss: 0.0084 - val_acc: 0.8411 - val_loss: 1.3243
Epoch 20/20
391/391 ━━━━━━━━━━━━━━━━━━━━ 5s 12ms/step - acc: 0.9996 - loss: 0.0045 - val_acc: 0.8406 - val_loss: 1.3812

import matplotlib.pyplot as plt

epochs = range(1,21)
model_b_val_loss = model_b_hist.history['val_loss']

plt.plot(epochs, model_val_loss, 'r+', label='Model')
plt.plot(epochs, model_s_val_loss, 'bo', label='Model(small)')
plt.plot(epochs, model_b_val_loss, 'g--', label='Model(big)')
plt.xlabel('Epochs')
plt.ylabel('Validation_Loss')
plt.legend()
plt.grid()
plt.show()

• 볼륨이 큰 신경망일수록 빠르게 훈련데이터 모델링 가능(학습 손실이 낮아짐)
• 과대 적합에는 더욱 민감해짐
• 이는 학습-검증 데이터 손실을 통해 확인 가능

model_train_loss = model_hist.history['loss']
model_s_train_loss = model_s_hist.history['loss']
model_b_train_loss = model_b_hist.history['loss']

import matplotlib.pyplot as plt

epochs = range(1,21)
model_b_val_loss = model_b_hist.history['val_loss']

plt.plot(epochs, model_train_loss, 'r+', label='Model')
plt.plot(epochs, model_s_train_loss, 'bo', label='Model(small)')
plt.plot(epochs, model_b_train_loss, 'g--', label='Model(big)')
plt.xlabel('Epochs')
plt.ylabel('Validation_Loss')
plt.legend()
plt.grid()
plt.show()

옵티마이저(Optimizer)

확률적 경사하강법(Stochastic Gradient Descent, SGD)

• 전체를 한번에 계산하지 않고, 확률적으로 일부 샘플을 뽑아 조금씩 나누어 학습을 시키는 과정

• 반복할 때마다 다루는 데이터의 수가 적기때문에 한 번 처리하는 속도는 빠름

• 한 번 학습할 때 필요한 메모리만 있으면 되므로 매우 큰 데이터셋에 대해서도 학습이 가능

• 확률적이기 때문에, 배치 경사하강법보다 불안정

• 손실함수의 최솟값에 이를 때까지 다소 위아래로 요동치면서 이동

• 따라서, 위와 같은 문제 때문에 미니 배치 경사하강법(mini-batch gradient descent)로 학습을 진행

• 요즘에는 보통 SGD라고하면 미니 배치 경사하강법을 의미하기도 함

• SGD의 단점: 단순하지만 문제에 따라서 시간이 매우 오래걸림

• SGD 수식

  $\quad W \leftarrow W - \gamma \frac{\partial L}{\partial W}$

  • $\gamma$ : 학습률

# 배치 경사하강법: 전체 데이터를 사용하여 1 에포크에 1번 업데이트.
# 미니배치 경사하강법: 지정된 배치 크기만큼의 데이터를 사용하여 1 에포크에 여러 번 업데이트.
# SGD: 각 업데이트마다 1개의 데이터 샘플을 사용. 1 에포크에 데이터 수만큼 업데이트.

Momentum

• 운동량을 의미, 관성과 관련

• 이전 단계에서의 업데이트 방향을 참고하여 현재 단계의 파라미터 업데이트에 일종의 관성을 부여하는 방법

• 공이 그릇의 경사면을 따라서 내려가는 듯한 모습 (가속도를 받아 점점 빠르게 이동하는 것처럼 파라미터 업데이트도 가속)

• 이전의 속도를 유지하려는 성향

• 경사하강을 좀 더 유지하려는 성격을 지님

• 단순히 SGD만 사용하는 것보다 적게 방향이 변함

• Momentum 수식

  $ \qquad v \ \leftarrow \ \alpha \ v - \gamma \ \frac{\partial L}{\partial W} \ \qquad W \ \leftarrow \ W \ + \ v $

  • $\alpha$ : 관성계수
  • $v$ : 속도
  • $\gamma$ : 학습률
  • $ \frac{\partial L}{\partial W}\ $ : 손실함수에 대한 미분

import tensorflow as tf
from tensorflow.keras.optimizers import SGD

optimizer = SGD(learning_rate=0.001, momentum=0.9)

Nesterov

• 모멘텀의 방향으로 조금 앞선 곳에서 손실함수의 그라디언트를 구함

• 시간이 지날수록 조금 더 빨리 최솟값에 도달

• Nesterov 수식

  $ \qquad m \ \leftarrow \ \beta m - \eta \bigtriangledown_\theta J(\theta + \beta m) \ \qquad \theta \ \leftarrow \ \theta \ + m $

  • $h$ : 기존 기울기를 제곱하여 더한 값
  • $\eta$ : 학습률
  • $ \bigtriangledown_\theta J(\theta) \ $ : $\theta$에 대한 미분(그라디언트)

import tensorflow as tf
from tensorflow.keras.optimizers import SGD

optimizer = SGD(learning_rate=0.001, momentum=0.9, nesterov=True)

AdaGrad(Adaptive Gradient)

• 가장 가파른 경사를 따라 빠르게 하강하는 방법

• 학습률을 변화시키며 진행하며 적응적 학습률이라고도 부름

• 경사가 급할 때는 빠르게 변화, 완만할 때는 느리게 변화

• 간단한 문제에서는 좋을 수는 있지만 딥러닝(Deep Learning)에서는 자주 쓰이지 않음

• 학습률이 너무 감소되어 전역최소값(global minimum)에 도달하기 전에 학습이 빨리 종료될 수 있기 때문

• AdaGrad 수식

  $ \qquad h \ \leftarrow \ h + \frac{\partial L}{\partial W} \odot \frac{\partial L}{\partial W} \ \qquad W \ \leftarrow \ W \ + \gamma \frac{1}{\sqrt h} \ \frac{\partial L}{\partial W} $

  • $h$ : 기존 기울기를 제곱하여 더한 값
  • $gamma$ : 학습률
  • $ \frac{\partial L}{\partial W}\ $ : $W$에 대한 미분
  • 과거의 기울기를 제곱하여 계속 더해하기 때문에 학습을 진행할수록 갱신 강도가 약해짐 ($\because \frac{1}{\sqrt h}$)

from tensorflow.keras.optimizers import Adagrad
optimizer = Adagrad(learning_rate = 0.001)

RMSProp (Root Mean Square Propagation)

• AdaGrad를 보완하기 위한 방법으로 등장

• 합 대신 지수의 평균값을 활용

• 학습이 안되기 시작하면 학습률이 커져서 잘 되게하고, 학습률이 너무 크면 학습률을 다시 줄임

• RMSProp 수식

  $ \qquad h \ \leftarrow \ \rho \ h + (1 - \rho)\ \frac{\partial L}{\partial W} \odot \frac{\partial L}{\partial W} \ \qquad W \ \leftarrow \ W \ + \gamma \frac{\partial L}{\partial W} / \ \sqrt{h + \epsilon} $

  • $h\ $ : 기존 기울기를 제곱하여 업데이트 계수를 곱한 값과 업데이트 계수를 곱한 값을 더해줌
  • $\rho\ $ : 지수 평균의 업데이트 계수
  • $\gamma\ $ : 학습률
  • $ \frac{\partial L}{\partial W}\ $ : $W$에 대한 미분

# RMSProp 최적화 알고리즘의 하이퍼파라미터 설명
# learning_rate: 학습률 (기본값 = 0.001)
# rho: 이전 기울기의 이동 평균을 계산하는 데 사용되는 감쇠율 (기본값 = 0.9)
# epsilon: 분모가 0이 되는 것을 방지하기 위한 작은 상수 (기본값 = 1e-7)
# momentum: 모멘텀 계수 (기본값 = 0.0)
# centered: True일 경우 RMSProp의 centered 버전 사용 (기본값 = False)

from tensorflow.keras.optimizers import RMSprop
optimizer = RMSprop(learning_rate = 0.001, rho=0.9) # rho : 지수 평균의 업데이트 계수

Adam (Adaptive Moment Estimation)

• 모멘텀 최적화와 RMSProp의 아이디어를 합친 것

• 지난 그래디언트의 지수 감소 평균을 따르고(Momentum), 지난 그레디언트 제곱의 지수 감소된 평균(RMSProp)을 따름

• 가장 많이 사용되는 최적화 방법

• Adam 수식

  $ \qquad t \ \leftarrow \ t + 1 \ \qquad m_t \ \leftarrow \ \beta_1 \ m_{t-1} - (1 - \beta_1)\ \frac{\partial L}{\partial W} \ \qquad v_t \ \leftarrow \ \beta_2 \ v_{t-1} + (1 - \beta_2) \frac{\partial L}{\partial W} \odot \frac{\partial L}{\partial W} \ \qquad \hat{m_t} \ \leftarrow \frac{m_t}{1 - \beta_1^t} \ \qquad \hat{v_t} \ \leftarrow \frac{v_t}{1 - \beta_2^t} \ \qquad W_t \ \leftarrow \ W_{t-1} \ + \gamma \ \hat{m_t}\ / \sqrt{\hat{v_t} + \epsilon} $

  • $\beta$ : 지수 평균의 업데이트 계수
  • $\gamma$ : 학습률
  • $\beta_1 \approx 0.9\ ,\ \ \beta_2 \approx 0.999$
  • $ \frac{\partial L}{\partial W}\ $ : $W$에 대한 미분

from tensorflow.keras.optimizers import Adam
optimizer = Adam(learning_rate = 0.001, beta_1=0.9, beta_2=0.999) # rho : 지수 평균의 업데이트 계수

최적화 Optimizer 비교

가중치 초기화(Weights Initialization)

• 가중치 초기화 시각화: https://www.deeplearning.ai/ai-notes/initialization/

가중치 소실(Gradient Vanishing)

• 활성화함수가 Sigmoid 함수 일 때, 은닉층의 갯수가 늘어 날수록 가중치가 역전파되면서 가중치 소실문제 발생

  • 시그모이드 함수의 미분값(0~1)사이 값이 거듭 곱해지면서 기울기가 출력층과 멀어질수록 미분값이 작아짐
  • 이는 미분값이 점점 0에 가까워짐을 의미하기도 함
  • ReLU 함수 등장(비선형 함수)

• 가중치 초기화 문제(은닉층의 활성화값 분포)

  • 가중치의 값이 일부 값으로 치우치게 되면, 활성화 함수를 통과한 값이 치우치게 되고, 표현할 수 있는 신경망의 수가 적어짐
  • 따라서, 활성화값이 골고루 분포되는 것이 중요

선형 함수에서 가중치 초기화

가중치 초기화의 중요성

• 가중치 초기화는 딥러닝 모델의 학습 성능에 큰 영향을 미치는 중요한 요소입니다
• 잘못된 가중치 초기화는 다음과 같은 문제를 일으킬 수 있습니다:
  • 기울기 소실(Gradient Vanishing) 또는 폭주(Exploding) 문제 발생
  • 학습 속도 저하
  • 모델이 제대로 수렴하지 못함

주요 가중치 초기화 방법:

1. 0으로 초기화

   • 모든 뉴런이 동일한 출력을 내어 학습이 제대로 이루어지지 않음
   • 실제로는 거의 사용되지 않음

2. 랜덤 초기화

   • 무작위로 작은 값을 할당
   • 간단하지만 깊은 신경망에서는 문제가 발생할 수 있음

3. Xavier/Glorot 초기화

   • sigmoid, tanh 활성화 함수에 적합
   • 입력과 출력 노드 수를 고려하여 초기화

4. He 초기화

   • ReLU 계열 활성화 함수에 적합
   • 입력 노드 수만 고려하여 초기화
   • 현대 딥러닝에서 가장 많이 사용되는 방식

적절한 가중치 초기화는 모델의 빠른 수렴과 좋은 성능을 위해 매우 중요합니다.

배치 정규화 (Batch Normalization)

• 모델에 주입되는 샘플들을 균일하게 만드는 방법
• 가중치의 활성화값이 적당히 퍼지게끔 '강제'로 적용시키는 것
• 미니배치 단위로 데이터의 평균이 0, 표준편차가 1로 정규화
• 학습을 빨리 진행할 수 있음
• 학습 후 새로운 데이터에 잘 일반화 할 수 있도록 도와줌
• 초기값에 크게 의존하지 않아도 됨
• 과대적합 방지
• 데이터 전처리 단계에서 진행해도 되지만 정규화가 되어서 layer에 들어갔다는 보장이 없음
• 주로 Dense 또는 Conv2D Layer 후, 활성화 함수이전에 놓임

규제화(Regularization) - 가중치 감소

• 과대적합(Overfitting, 오버피팅)을 방지하는 방법 중 하나

• 과대적합은 가중치의 매개변수 값이 커서 발생하는 경우가 많음
  이를 방지하기 위해 큰 가중치 값에 큰 규제를 가하는 것

• 규제란 가중치의 절댓값을 가능한 작게 만드는 것으로, 가중치의 모든 원소를 0에 가깝게 하여 모든 특성이 출력에 주는 영향을 최소한으로 만드는 것(기울기를 작게 만드는 것)을 의미

• 가중치의 분포가 더 균일하게 됨

• 복잡한 네트워크 일수록 네트워크의 복잡도에 제한을 두어 가중치가 작은 값을 가지도록 함

• 규제란 과대적합이 되지 않도록 모델을 강제로 제한한다는 의미

• 적절한 규제값을 찾는 것이 중요

• 네트워크 손실함수에 큰 가중치와 연관된 비용을 추가

  • L1 규제: 가중치의 절댓값에 비례하는 비용이 추가
  • L2 규제: 가중치의 제곱에 비례하는 비용이 추가(흔히 가중치 감쇠라고도 불림)
  • 위 두 규제가 합쳐진 경우도 존재

L2 규제

• 가중치의 제곱합

• 손실 함수일정 값을 더함으로써 과적합을 방지

• $\lambda$ 값이 크면 가중치 감소가 커지고, 작으면 가하는 규제가 적어진다.

• 더 Robust한 모델을 생성하므로 L1보다 많이 사용됨

  $\qquad Cost = \frac{1}{n} \sum{^n}_{i=1} {L(y_i, \hat{y_i}) + \frac{\lambda}{2}w^2}$

  $\quad L(y_i, \hat{y_i})$ : 기존 Cost Function

from tensorflow.keras.regularizers import l1, l2, l1_l2

l2_model =  Sequential([Dense(16, kernel_regularizer=l2(0.001), activation='relu', input_shape=(10000,)),
                        Dense(16, kernel_regularizer=l2(0.001), activation='relu'),
                        Dense(1, activation='relu')])
l2_model.compile(optimizer='rmsprop',
                loss='binary_crossentropy',
                metrics=['acc'])
l2_model.summary()

plot_model(l2_model, show_shapes= True)

Model: "sequential_5"

┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓
┃ Layer (type)                    ┃ Output Shape           ┃       Param # ┃
┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩
│ dense_3 (Dense)                 │ (None, 16)             │       160,016 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ dense_4 (Dense)                 │ (None, 16)             │           272 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ dense_5 (Dense)                 │ (None, 1)              │            17 │
└─────────────────────────────────┴────────────────────────┴───────────────┘

 Total params: 160,305 (626.19 KB)

 Trainable params: 160,305 (626.19 KB)

 Non-trainable params: 0 (0.00 B)

l2_model_hist = l2_model.fit(x_train, y_train, epochs=20, batch_size=512, validation_data=(x_test, y_test))

Epoch 1/20
49/49 ━━━━━━━━━━━━━━━━━━━━ 4s 60ms/step - acc: 0.6195 - loss: 1.1389 - val_acc: 0.8515 - val_loss: 0.4708
Epoch 2/20
49/49 ━━━━━━━━━━━━━━━━━━━━ 1s 14ms/step - acc: 0.8906 - loss: 0.3756 - val_acc: 0.8719 - val_loss: 0.4776
Epoch 3/20
49/49 ━━━━━━━━━━━━━━━━━━━━ 1s 13ms/step - acc: 0.9220 - loss: 0.3026 - val_acc: 0.8650 - val_loss: 0.6070
Epoch 4/20
49/49 ━━━━━━━━━━━━━━━━━━━━ 1s 12ms/step - acc: 0.9390 - loss: 0.2672 - val_acc: 0.8688 - val_loss: 0.7094
Epoch 5/20
49/49 ━━━━━━━━━━━━━━━━━━━━ 1s 12ms/step - acc: 0.9469 - loss: 0.2527 - val_acc: 0.8731 - val_loss: 0.6746
Epoch 6/20
49/49 ━━━━━━━━━━━━━━━━━━━━ 1s 12ms/step - acc: 0.9605 - loss: 0.2319 - val_acc: 0.8571 - val_loss: 0.8224
Epoch 7/20
49/49 ━━━━━━━━━━━━━━━━━━━━ 1s 12ms/step - acc: 0.9652 - loss: 0.2242 - val_acc: 0.8745 - val_loss: 0.7368
Epoch 8/20
49/49 ━━━━━━━━━━━━━━━━━━━━ 1s 14ms/step - acc: 0.9697 - loss: 0.2041 - val_acc: 0.8601 - val_loss: 0.9735
Epoch 9/20
49/49 ━━━━━━━━━━━━━━━━━━━━ 1s 13ms/step - acc: 0.9666 - loss: 0.2243 - val_acc: 0.8762 - val_loss: 0.8641
Epoch 10/20
49/49 ━━━━━━━━━━━━━━━━━━━━ 1s 13ms/step - acc: 0.9781 - loss: 0.2031 - val_acc: 0.8730 - val_loss: 0.9077
Epoch 11/20
49/49 ━━━━━━━━━━━━━━━━━━━━ 1s 13ms/step - acc: 0.9798 - loss: 0.1919 - val_acc: 0.8635 - val_loss: 1.0065
Epoch 12/20
49/49 ━━━━━━━━━━━━━━━━━━━━ 1s 12ms/step - acc: 0.9791 - loss: 0.1866 - val_acc: 0.8603 - val_loss: 1.0797
Epoch 13/20
49/49 ━━━━━━━━━━━━━━━━━━━━ 1s 12ms/step - acc: 0.9816 - loss: 0.1798 - val_acc: 0.8593 - val_loss: 1.0720
Epoch 14/20
49/49 ━━━━━━━━━━━━━━━━━━━━ 1s 12ms/step - acc: 0.9860 - loss: 0.1669 - val_acc: 0.8703 - val_loss: 1.0340
Epoch 15/20
49/49 ━━━━━━━━━━━━━━━━━━━━ 1s 13ms/step - acc: 0.9851 - loss: 0.1734 - val_acc: 0.8697 - val_loss: 0.9297
Epoch 16/20
49/49 ━━━━━━━━━━━━━━━━━━━━ 1s 13ms/step - acc: 0.9899 - loss: 0.1516 - val_acc: 0.8712 - val_loss: 0.9510
Epoch 17/20
49/49 ━━━━━━━━━━━━━━━━━━━━ 1s 16ms/step - acc: 0.9927 - loss: 0.1462 - val_acc: 0.8692 - val_loss: 1.0476
Epoch 18/20
49/49 ━━━━━━━━━━━━━━━━━━━━ 1s 15ms/step - acc: 0.9868 - loss: 0.1620 - val_acc: 0.8667 - val_loss: 1.1164
Epoch 19/20
49/49 ━━━━━━━━━━━━━━━━━━━━ 1s 15ms/step - acc: 0.9875 - loss: 0.1554 - val_acc: 0.8704 - val_loss: 1.0520
Epoch 20/20
49/49 ━━━━━━━━━━━━━━━━━━━━ 1s 13ms/step - acc: 0.9857 - loss: 0.1759 - val_acc: 0.8661 - val_loss: 1.0929

import matplotlib.pyplot as plt
epochs = range(1,21)
model_val_loss = model_hist.history['val_loss']
l2_model_val_loss = l2_model_hist.history['val_loss']

plt.plot(epochs, model_val_loss, 'r+', label='Model')
plt.plot(epochs, l2_model_val_loss, 'bo', label='Model(l2_regularize)')
plt.xlabel('Epochs')
plt.ylabel('Validation_Loss')
plt.legend()
plt.grid()
plt.show()

L1 규제

• 가중치의 절대값합

• L2 규제와 달리 어떤 가중치는 0이 되는데 이는 모델이 가벼워짐을 의미

  $\qquad Cost = \frac{1}{n} \sum{^n}_{i=1} {L(y_i, \hat{y_i}) + \frac{\lambda}{2}|w|}$

  $\quad L(y_i, \hat{y_i})$ : 기존 Cost Function

from tensorflow.keras.regularizers import l1, l2, l1_l2

l1_model =  Sequential([Dense(16, kernel_regularizer=l1(0.0001), activation='relu', input_shape=(10000,)),
                        Dense(16, kernel_regularizer=l1(0.0001), activation='relu'),
                        Dense(1, activation='relu')])
l1_model.compile(optimizer='rmsprop',
                loss='binary_crossentropy',
                metrics=['acc'])
l1_model.summary()

plot_model(l1_model, show_shapes= True)

Model: "sequential_7"

┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓
┃ Layer (type)                    ┃ Output Shape           ┃       Param # ┃
┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩
│ dense_9 (Dense)                 │ (None, 16)             │       160,016 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ dense_10 (Dense)                │ (None, 16)             │           272 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ dense_11 (Dense)                │ (None, 1)              │            17 │
└─────────────────────────────────┴────────────────────────┴───────────────┘

 Total params: 160,305 (626.19 KB)

 Trainable params: 160,305 (626.19 KB)

 Non-trainable params: 0 (0.00 B)

l1_model_hist = l1_model.fit(x_train, y_train, epochs=20, batch_size=512, validation_data=(x_test, y_test))

Epoch 1/20
49/49 ━━━━━━━━━━━━━━━━━━━━ 4s 38ms/step - acc: 0.6668 - loss: 0.9749 - val_acc: 0.8598 - val_loss: 0.5532
Epoch 2/20
49/49 ━━━━━━━━━━━━━━━━━━━━ 1s 16ms/step - acc: 0.8981 - loss: 0.4217 - val_acc: 0.8712 - val_loss: 0.4843
Epoch 3/20
49/49 ━━━━━━━━━━━━━━━━━━━━ 1s 14ms/step - acc: 0.9207 - loss: 0.3406 - val_acc: 0.8674 - val_loss: 0.5072
Epoch 4/20
49/49 ━━━━━━━━━━━━━━━━━━━━ 1s 14ms/step - acc: 0.9268 - loss: 0.3240 - val_acc: 0.8785 - val_loss: 0.5719
Epoch 5/20
49/49 ━━━━━━━━━━━━━━━━━━━━ 1s 14ms/step - acc: 0.9398 - loss: 0.2952 - val_acc: 0.8329 - val_loss: 0.7560
Epoch 6/20
49/49 ━━━━━━━━━━━━━━━━━━━━ 1s 15ms/step - acc: 0.9373 - loss: 0.2952 - val_acc: 0.8701 - val_loss: 0.6519
Epoch 7/20
49/49 ━━━━━━━━━━━━━━━━━━━━ 1s 17ms/step - acc: 0.9491 - loss: 0.2649 - val_acc: 0.8672 - val_loss: 0.8465
Epoch 8/20
49/49 ━━━━━━━━━━━━━━━━━━━━ 1s 15ms/step - acc: 0.9519 - loss: 0.2617 - val_acc: 0.8752 - val_loss: 0.7189
Epoch 9/20
49/49 ━━━━━━━━━━━━━━━━━━━━ 1s 15ms/step - acc: 0.9608 - loss: 0.2440 - val_acc: 0.8656 - val_loss: 0.7736
Epoch 10/20
49/49 ━━━━━━━━━━━━━━━━━━━━ 1s 14ms/step - acc: 0.9607 - loss: 0.2518 - val_acc: 0.8726 - val_loss: 0.7548
Epoch 11/20
49/49 ━━━━━━━━━━━━━━━━━━━━ 1s 15ms/step - acc: 0.9654 - loss: 0.2299 - val_acc: 0.8699 - val_loss: 0.8351
Epoch 12/20
49/49 ━━━━━━━━━━━━━━━━━━━━ 1s 14ms/step - acc: 0.9686 - loss: 0.2313 - val_acc: 0.8734 - val_loss: 0.8613
Epoch 13/20
49/49 ━━━━━━━━━━━━━━━━━━━━ 1s 14ms/step - acc: 0.9705 - loss: 0.2281 - val_acc: 0.8725 - val_loss: 0.9518
Epoch 14/20
49/49 ━━━━━━━━━━━━━━━━━━━━ 1s 14ms/step - acc: 0.9745 - loss: 0.2085 - val_acc: 0.8719 - val_loss: 0.9590
Epoch 15/20
49/49 ━━━━━━━━━━━━━━━━━━━━ 1s 14ms/step - acc: 0.9778 - loss: 0.2045 - val_acc: 0.8430 - val_loss: 1.1934
Epoch 16/20
49/49 ━━━━━━━━━━━━━━━━━━━━ 1s 15ms/step - acc: 0.9732 - loss: 0.2112 - val_acc: 0.8647 - val_loss: 1.1163
Epoch 17/20
49/49 ━━━━━━━━━━━━━━━━━━━━ 1s 15ms/step - acc: 0.9785 - loss: 0.2000 - val_acc: 0.8713 - val_loss: 1.0503
Epoch 18/20
49/49 ━━━━━━━━━━━━━━━━━━━━ 1s 16ms/step - acc: 0.9834 - loss: 0.1952 - val_acc: 0.8688 - val_loss: 1.0961
Epoch 19/20
49/49 ━━━━━━━━━━━━━━━━━━━━ 1s 17ms/step - acc: 0.9847 - loss: 0.1890 - val_acc: 0.8704 - val_loss: 1.0849
Epoch 20/20
49/49 ━━━━━━━━━━━━━━━━━━━━ 1s 17ms/step - acc: 0.9861 - loss: 0.1807 - val_acc: 0.8697 - val_loss: 1.1318

epochs = range(1,21)
model_val_loss = model_hist.history['val_loss']
l1_model_val_loss = l1_model_hist.history['val_loss']

plt.plot(epochs, model_val_loss, 'r+', label='Model')
plt.plot(epochs, l1_model_val_loss, 'bo', label='Model(l1_regularize)')
plt.xlabel('Epochs')
plt.ylabel('Validation_Loss')
plt.legend()
plt.grid()
plt.show()

L1 L2 규제

from tensorflow.keras.regularizers import l1, l2, l1_l2

l1_l2_model =  Sequential([Dense(16, kernel_regularizer=l1_l2(l1=0.0001, l2=0.0001), activation='relu', input_shape=(10000,)),
                           Dense(16, kernel_regularizer=l1_l2(l1=0.0001, l2=0.0001), activation='relu'),
                           Dense(1, activation='sigmoid')])

l1_l2_model.compile(optimizer='rmsprop',
                loss='binary_crossentropy',
                metrics=['acc'])
l1_l2_model.summary()

plot_model(l1_l2_model, show_shapes= True)

Model: "sequential_8"

┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓
┃ Layer (type)                    ┃ Output Shape           ┃       Param # ┃
┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩
│ dense_12 (Dense)                │ (None, 16)             │       160,016 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ dense_13 (Dense)                │ (None, 16)             │           272 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ dense_14 (Dense)                │ (None, 1)              │            17 │
└─────────────────────────────────┴────────────────────────┴───────────────┘

 Total params: 160,305 (626.19 KB)

 Trainable params: 160,305 (626.19 KB)

 Non-trainable params: 0 (0.00 B)

l1_l2_model_hist = l1_l2_model.fit(x_train, y_train, epochs=20, batch_size=512, validation_data=(x_test, y_test))

Epoch 1/20
49/49 ━━━━━━━━━━━━━━━━━━━━ 2s 31ms/step - acc: 0.7163 - loss: 0.7340 - val_acc: 0.8803 - val_loss: 0.4520
Epoch 2/20
49/49 ━━━━━━━━━━━━━━━━━━━━ 1s 14ms/step - acc: 0.8981 - loss: 0.4003 - val_acc: 0.8698 - val_loss: 0.4016
Epoch 3/20
49/49 ━━━━━━━━━━━━━━━━━━━━ 1s 15ms/step - acc: 0.9076 - loss: 0.3374 - val_acc: 0.8869 - val_loss: 0.3623
Epoch 4/20
49/49 ━━━━━━━━━━━━━━━━━━━━ 1s 16ms/step - acc: 0.9084 - loss: 0.3187 - val_acc: 0.8828 - val_loss: 0.3671
Epoch 5/20
49/49 ━━━━━━━━━━━━━━━━━━━━ 1s 18ms/step - acc: 0.9136 - loss: 0.3091 - val_acc: 0.8850 - val_loss: 0.3630
Epoch 6/20
49/49 ━━━━━━━━━━━━━━━━━━━━ 1s 14ms/step - acc: 0.9169 - loss: 0.2990 - val_acc: 0.8856 - val_loss: 0.3611
Epoch 7/20
49/49 ━━━━━━━━━━━━━━━━━━━━ 1s 14ms/step - acc: 0.9212 - loss: 0.2912 - val_acc: 0.8716 - val_loss: 0.3936
Epoch 8/20
49/49 ━━━━━━━━━━━━━━━━━━━━ 1s 14ms/step - acc: 0.9246 - loss: 0.2853 - val_acc: 0.8750 - val_loss: 0.3913
Epoch 9/20
49/49 ━━━━━━━━━━━━━━━━━━━━ 1s 15ms/step - acc: 0.9265 - loss: 0.2830 - val_acc: 0.8809 - val_loss: 0.3786
Epoch 10/20
49/49 ━━━━━━━━━━━━━━━━━━━━ 1s 15ms/step - acc: 0.9304 - loss: 0.2692 - val_acc: 0.8778 - val_loss: 0.3820
Epoch 11/20
49/49 ━━━━━━━━━━━━━━━━━━━━ 1s 15ms/step - acc: 0.9329 - loss: 0.2680 - val_acc: 0.8766 - val_loss: 0.3869
Epoch 12/20
49/49 ━━━━━━━━━━━━━━━━━━━━ 1s 15ms/step - acc: 0.9372 - loss: 0.2570 - val_acc: 0.8793 - val_loss: 0.3808
Epoch 13/20
49/49 ━━━━━━━━━━━━━━━━━━━━ 1s 13ms/step - acc: 0.9373 - loss: 0.2601 - val_acc: 0.8820 - val_loss: 0.3767
Epoch 14/20
49/49 ━━━━━━━━━━━━━━━━━━━━ 1s 14ms/step - acc: 0.9354 - loss: 0.2566 - val_acc: 0.8665 - val_loss: 0.4184
Epoch 15/20
49/49 ━━━━━━━━━━━━━━━━━━━━ 1s 15ms/step - acc: 0.9390 - loss: 0.2523 - val_acc: 0.8725 - val_loss: 0.4026
Epoch 16/20
49/49 ━━━━━━━━━━━━━━━━━━━━ 1s 13ms/step - acc: 0.9418 - loss: 0.2418 - val_acc: 0.8782 - val_loss: 0.3865
Epoch 17/20
49/49 ━━━━━━━━━━━━━━━━━━━━ 1s 14ms/step - acc: 0.9497 - loss: 0.2311 - val_acc: 0.8783 - val_loss: 0.3876
Epoch 18/20
49/49 ━━━━━━━━━━━━━━━━━━━━ 1s 14ms/step - acc: 0.9451 - loss: 0.2355 - val_acc: 0.8767 - val_loss: 0.3940
Epoch 19/20
49/49 ━━━━━━━━━━━━━━━━━━━━ 1s 13ms/step - acc: 0.9439 - loss: 0.2330 - val_acc: 0.8772 - val_loss: 0.3932
Epoch 20/20
49/49 ━━━━━━━━━━━━━━━━━━━━ 1s 14ms/step - acc: 0.9499 - loss: 0.2245 - val_acc: 0.8680 - val_loss: 0.4272

epochs = range(1,21)
model_val_loss = model_hist.history['val_loss']
l1_l2_model_val_loss = l1_l2_model_hist.history['val_loss']

plt.plot(epochs, model_val_loss, 'r+', label='Model')
plt.plot(epochs, l1_l2_model_val_loss, 'bo', label='Model(l1_l2_regularize)')
plt.xlabel('Epochs')
plt.ylabel('Validation_Loss')
plt.legend()
plt.grid()
plt.show()

• 규제 방법 비교

epochs = range(1,21)
model_val_loss = model_hist.history['val_loss']
l1_model_val_loss = l1_model_hist.history['val_loss']
l2_model_val_loss = l2_model_hist.history['val_loss']
l1_l2_model_val_loss = l1_l2_model_hist.history['val_loss']

plt.plot(epochs, model_val_loss, 'r+', label='Model')
plt.plot(epochs, l1_model_val_loss, 'bo', label='Model(l1_regularize)')
plt.plot(epochs, l2_model_val_loss, 'g--', label='Model(l2_regularize)')
plt.plot(epochs, l1_l2_model_val_loss, 'ko', label='Model(l1_l2_regularize)')
plt.xlabel('Epochs')
plt.ylabel('Validation_Loss')
plt.legend()
plt.grid()
plt.show()

드롭아웃(Dropout)

• 신경망을 위해 사용되는 규제 기법 중 가장 효과적이고 널리 사용되는 방법

• 과적합을 방지하기 위한 방법

• 학습할 때 사용하는 노드의 수를 전체 노드 중에서 일부만을 사용

• 신경망의 레이어에 드롭아웃을 적용하면 훈련하는 동안 무작위로 층의 일부 특성(노드)를 제외

  • 예를 들어, [1.0, 3.2, 0.6, 0.8, 1.1] 라는 벡터에 대해 드롭아웃을 적용하면 무작위로 0으로 바뀜 $\rightarrow$ [0, 3.2, 0.6, 0.8, 0]
  • 보통 0.2 ~ 0.5 사이의 비율로 지정됨

• 테스트 단계에서는 그 어떤 노드도 드롭아웃 되지 않고, 대신 해당 레이어의 출력 노드를 드롭아웃 비율에 맞게 줄여줌(ex 0.2 -> *1.25)

  

from tensorflow.keras.regularizers import l1, l2, l1_l2
from tensorflow.keras.layers import Dropout, Dense
from tensorflow.keras.models import Sequential
from tensorflow.keras.utils import plot_model

dropout_model =  Sequential([Dense(16, activation='relu', input_shape=(10000,)),
                             Dropout(0.5),
                             Dense(16, activation='relu'),
                             Dropout(0.5),
                             Dense(1, activation='sigmoid')])

dropout_model.compile(optimizer='rmsprop',
                loss='binary_crossentropy',
                metrics=['acc'])
dropout_model.summary()

plot_model(dropout_model, show_shapes= True)

dropout_model_hist = dropout_model.fit(x_train, y_train, epochs=20, batch_size=512, validation_data=(x_test, y_test))

dropout_model_hist = dropout_model_hist.history['val_loss']

epochs = range(1,21)
plt.plot(epochs, model_val_loss, 'r+', label='Model')
plt.plot(epochs, dropout_model_val_loss, 'bo', label='Model(Dropout)')
plt.xlabel('Epochs')
plt.ylabel('Validation_Loss')
plt.legend()
plt.grid()
plt.show()

하이퍼 파라미터(Hyper Parameter)

• 사람이 직접 설정해야하는 매개변수
• 학습이 되기전 미리 설정되어 상수취급

학습률(Learning Rate)

• 학습률에 따라 학습정도가 달라짐
• 적절한 학습률을 찾는 것이 핵심

학습 횟수(Epochs)

• 학습 횟수를 너무 작게, 또는 너무 크게 지정하면 과소적합 또는 과대적합 발생
• 여러번 진행하면서 최적의 학습 횟수(epochs)값을 찾아야함

미니배치 크기(Mini Batch Size)

• 미니 배치 학습
  • 한번 학습할 때 메모리의 부족현상을 막기 위해 전체 데이터의 일부를 여러번 학습하는 방식
• 한번 학습할 때마다 얼마만큼의 미니배치 크기를 사용할지 결정
• 배치 크기가 작을수록 학습 시간이 많이 소요되고, 클수록 학습 시간이 학습 시간은 적게 소요된다.

검증데이터(Validation Data)

• 주어진 데이터를 학습 + 검증 + 테스트 데이터로 구분하여 과적합을 방지

• 일반적으로 전체 데이터의 2~30%를 테스트 데이터, 나머지에서 20%정도를 검증용 데이터, 남은 부분을 학습용 데이터로 사용

  

Fashion MNIST 모델

모듈 임포트

import tensorflow as tf
from tensorflow.keras.datasets.fashion_mnist import load_data
from tensorflow.keras.models import Sequential, Model
from tensorflow.keras import models, Input
from tensorflow.keras.layers import Dense, Flatten
from tensorflow.keras.utils import plot_model
from tensorflow.keras.optimizers import Adam

from sklearn.model_selection import train_test_split

import numpy as np
import matplotlib.pyplot as plt
plt.style.use('seaborn-v0_8-white')

데이터 로드

tf.random.set_seed(42)
np.random.seed(42)

(x_train_full,y_train_full), (x_test,y_test) = load_data()

x_train, x_valid, y_train, y_valid = train_test_split(x_train_full, y_train_full, test_size=0.3, random_state=42)

Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/train-labels-idx1-ubyte.gz
29515/29515 ━━━━━━━━━━━━━━━━━━━━ 0s 0us/step
Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/train-images-idx3-ubyte.gz
26421880/26421880 ━━━━━━━━━━━━━━━━━━━━ 1s 0us/step
Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/t10k-labels-idx1-ubyte.gz
5148/5148 ━━━━━━━━━━━━━━━━━━━━ 0s 1us/step
Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/t10k-images-idx3-ubyte.gz
4422102/4422102 ━━━━━━━━━━━━━━━━━━━━ 0s 0us/step

print(f"학습 데이터 : {x_train.shape}")
print(f"검증 데이터 : {x_valid.shape}")
print(f"테스트 데이터 : {x_test.shape}")

학습 데이터 : (42000, 28, 28)
검증 데이터 : (18000, 28, 28)
테스트 데이터 : (10000, 28, 28)

class_names = ['T-shirt/Top', 'Trouser', 'Pullover', 'Dress', 'Coat',
               'Sandal', 'Shirt', 'Sneaker', 'Bag', 'Ankle boot']

class_names[y_train[0]]

'Trouser'

plt.figure()
plt.imshow(x_train[0], cmap='gray')
plt.colorbar()
plt.grid(False)
plt.show()

num_sample = 4
random_idxs = np.random.randint(60000, size=num_sample)

plt.figure(figsize=(10,10))
for i, idx in enumerate(random_idxs):
    image = x_train_full[idx]
    label = y_train_full[idx]
    plt.subplot(1,len(random_idxs),i+1)
    plt.imshow(image, cmap='gray')
    plt.title(f'index: {idx} label : {class_names[label]}')
plt.show()

데이터 전처리

• Normalization
• Flatten
• loss='sparse_categorical_crossentropy'

# 데이터 전처리
# 1. 이미지 데이터를 1차원 배열로 변환 (Flatten)
# 2. 픽셀값을 0~1 사이로 정규화 (Normalization)
# - 원본 이미지의 픽셀값(0~255)을 255로 나누어 0~1 사이의 값으로 변환
# - 이는 모델의 학습을 안정화하고 성능을 향상시키는데 도움이 됨

x_train = (x_train.reshape(-1,28*28))/255.0
x_valid = (x_valid.reshape(-1,28*28))/255.0
x_test = (x_test.reshape(-1,28*28))/255.0

모델 구성 (함수형 API)

input = Input(shape=(784, ), name='input')
hidden1 = Dense(512, activation='relu', name='hidden1')(input)
hidden2 = Dense(256, activation='relu', name='hidden2')(hidden1)
hidden3 = Dense(128, activation='relu', name='hidden3')(hidden2)
hidden4 = Dense(64, activation='relu', name='hidden4')(hidden3)
hidden5 = Dense(32, activation='relu', name='hidden5')(hidden4)
output = Dense(10, activation='softmax', name='output')(hidden5)

model = Model(inputs=[input], outputs=[output])
model.summary()

Model: "functional_9"

┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓
┃ Layer (type)                    ┃ Output Shape           ┃       Param # ┃
┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩
│ input (InputLayer)              │ (None, 784)            │             0 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ hidden1 (Dense)                 │ (None, 512)            │       401,920 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ hidden2 (Dense)                 │ (None, 256)            │       131,328 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ hidden3 (Dense)                 │ (None, 128)            │        32,896 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ hidden4 (Dense)                 │ (None, 64)             │         8,256 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ hidden5 (Dense)                 │ (None, 32)             │         2,080 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ output (Dense)                  │ (None, 10)             │           330 │
└─────────────────────────────────┴────────────────────────┴───────────────┘

 Total params: 576,810 (2.20 MB)

 Trainable params: 576,810 (2.20 MB)

 Non-trainable params: 0 (0.00 B)

plot_model(model, show_shapes=True)

모델 컴파일 및 학습

model.compile(optimizer=Adam(learning_rate=0.01), #optimizer='adam'
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])

history = model.fit(x_train, y_train, epochs=30, batch_size=512, validation_data=(x_valid, y_valid))

Epoch 1/30


c:\Users\rlaal\anaconda3\envs\py39\lib\site-packages\keras\src\models\functional.py:225: UserWarning: The structure of `inputs` doesn't match the expected structure: ['input']. Received: the structure of inputs=*
  warnings.warn(


83/83 ━━━━━━━━━━━━━━━━━━━━ 2s 12ms/step - accuracy: 0.3034 - loss: 1.9492 - val_accuracy: 0.7751 - val_loss: 0.6158
Epoch 2/30
83/83 ━━━━━━━━━━━━━━━━━━━━ 1s 11ms/step - accuracy: 0.7996 - loss: 0.5476 - val_accuracy: 0.8348 - val_loss: 0.4601
Epoch 3/30
83/83 ━━━━━━━━━━━━━━━━━━━━ 1s 8ms/step - accuracy: 0.8393 - loss: 0.4550 - val_accuracy: 0.8389 - val_loss: 0.4614
Epoch 4/30
83/83 ━━━━━━━━━━━━━━━━━━━━ 1s 8ms/step - accuracy: 0.8516 - loss: 0.4150 - val_accuracy: 0.8584 - val_loss: 0.4023
Epoch 5/30
83/83 ━━━━━━━━━━━━━━━━━━━━ 1s 8ms/step - accuracy: 0.8665 - loss: 0.3737 - val_accuracy: 0.8308 - val_loss: 0.4939
Epoch 6/30
83/83 ━━━━━━━━━━━━━━━━━━━━ 1s 8ms/step - accuracy: 0.8676 - loss: 0.3632 - val_accuracy: 0.8564 - val_loss: 0.4082
Epoch 7/30
83/83 ━━━━━━━━━━━━━━━━━━━━ 1s 8ms/step - accuracy: 0.8743 - loss: 0.3482 - val_accuracy: 0.8453 - val_loss: 0.4332
Epoch 8/30
83/83 ━━━━━━━━━━━━━━━━━━━━ 1s 9ms/step - accuracy: 0.8768 - loss: 0.3420 - val_accuracy: 0.8468 - val_loss: 0.4441
Epoch 9/30
83/83 ━━━━━━━━━━━━━━━━━━━━ 1s 9ms/step - accuracy: 0.8767 - loss: 0.3417 - val_accuracy: 0.8527 - val_loss: 0.4351
Epoch 10/30
83/83 ━━━━━━━━━━━━━━━━━━━━ 1s 8ms/step - accuracy: 0.8837 - loss: 0.3291 - val_accuracy: 0.8513 - val_loss: 0.4447
Epoch 11/30
83/83 ━━━━━━━━━━━━━━━━━━━━ 1s 8ms/step - accuracy: 0.8858 - loss: 0.3190 - val_accuracy: 0.8626 - val_loss: 0.3964
Epoch 12/30
83/83 ━━━━━━━━━━━━━━━━━━━━ 1s 8ms/step - accuracy: 0.8885 - loss: 0.3064 - val_accuracy: 0.8612 - val_loss: 0.4014
Epoch 13/30
83/83 ━━━━━━━━━━━━━━━━━━━━ 1s 9ms/step - accuracy: 0.8947 - loss: 0.2927 - val_accuracy: 0.8724 - val_loss: 0.3677
Epoch 14/30
83/83 ━━━━━━━━━━━━━━━━━━━━ 1s 8ms/step - accuracy: 0.8997 - loss: 0.2777 - val_accuracy: 0.8612 - val_loss: 0.4183
Epoch 15/30
83/83 ━━━━━━━━━━━━━━━━━━━━ 1s 8ms/step - accuracy: 0.8975 - loss: 0.2814 - val_accuracy: 0.8723 - val_loss: 0.3795
Epoch 16/30
83/83 ━━━━━━━━━━━━━━━━━━━━ 1s 9ms/step - accuracy: 0.9029 - loss: 0.2719 - val_accuracy: 0.8677 - val_loss: 0.3961
Epoch 17/30
83/83 ━━━━━━━━━━━━━━━━━━━━ 1s 9ms/step - accuracy: 0.8981 - loss: 0.2778 - val_accuracy: 0.8722 - val_loss: 0.3951
Epoch 18/30
83/83 ━━━━━━━━━━━━━━━━━━━━ 1s 8ms/step - accuracy: 0.9055 - loss: 0.2661 - val_accuracy: 0.8683 - val_loss: 0.4019
Epoch 19/30
83/83 ━━━━━━━━━━━━━━━━━━━━ 1s 8ms/step - accuracy: 0.9061 - loss: 0.2619 - val_accuracy: 0.8608 - val_loss: 0.4385
Epoch 20/30
83/83 ━━━━━━━━━━━━━━━━━━━━ 1s 9ms/step - accuracy: 0.9018 - loss: 0.2661 - val_accuracy: 0.8720 - val_loss: 0.4100
Epoch 21/30
83/83 ━━━━━━━━━━━━━━━━━━━━ 1s 8ms/step - accuracy: 0.9072 - loss: 0.2547 - val_accuracy: 0.8704 - val_loss: 0.4092
Epoch 22/30
83/83 ━━━━━━━━━━━━━━━━━━━━ 1s 8ms/step - accuracy: 0.9081 - loss: 0.2513 - val_accuracy: 0.8589 - val_loss: 0.4590
Epoch 23/30
83/83 ━━━━━━━━━━━━━━━━━━━━ 1s 8ms/step - accuracy: 0.9085 - loss: 0.2563 - val_accuracy: 0.8642 - val_loss: 0.4246
Epoch 24/30
83/83 ━━━━━━━━━━━━━━━━━━━━ 1s 8ms/step - accuracy: 0.9080 - loss: 0.2517 - val_accuracy: 0.8643 - val_loss: 0.4217
Epoch 25/30
83/83 ━━━━━━━━━━━━━━━━━━━━ 1s 8ms/step - accuracy: 0.9070 - loss: 0.2497 - val_accuracy: 0.8701 - val_loss: 0.4414
Epoch 26/30
83/83 ━━━━━━━━━━━━━━━━━━━━ 1s 8ms/step - accuracy: 0.9123 - loss: 0.2424 - val_accuracy: 0.8581 - val_loss: 0.4511
Epoch 27/30
83/83 ━━━━━━━━━━━━━━━━━━━━ 1s 8ms/step - accuracy: 0.9082 - loss: 0.2515 - val_accuracy: 0.8727 - val_loss: 0.3929
Epoch 28/30
83/83 ━━━━━━━━━━━━━━━━━━━━ 1s 8ms/step - accuracy: 0.9161 - loss: 0.2290 - val_accuracy: 0.8709 - val_loss: 0.4317
Epoch 29/30
83/83 ━━━━━━━━━━━━━━━━━━━━ 1s 8ms/step - accuracy: 0.9166 - loss: 0.2292 - val_accuracy: 0.8663 - val_loss: 0.4316
Epoch 30/30
83/83 ━━━━━━━━━━━━━━━━━━━━ 1s 9ms/step - accuracy: 0.9153 - loss: 0.2345 - val_accuracy: 0.8696 - val_loss: 0.4381

# 기록을 눈으로 보기 편하게 시각화

history_dict = history.history

loss = history_dict['loss']
val_loss = history_dict['val_loss']

epochs = range(1, len(loss)+1)
fig = plt.figure(figsize=(12,5))

ax1 = fig.add_subplot(1, 2, 1) # 행 / 열 / 위치
ax1.plot(epochs, loss, color='blue', label='train_loss')
ax1.plot(epochs, val_loss, color='red', label='val_loss')

ax1.set_title('Train and Validation Loss')
ax1.set_xlabel('Epochs')
ax1.set_ylabel('Loss')
ax1.grid()
ax1.legend()


accuracy = history_dict['accuracy']
val_accuracy = history_dict['val_accuracy']

ax2 = fig.add_subplot(1, 2, 2)
ax2.plot(epochs, accuracy, color='blue', label='train_accuracy')
ax2.plot(epochs, val_accuracy, color='red', label='val_accuracy')

ax2.set_title('Train and Validation accuracy')
ax2.set_xlabel('Epochs')
ax2.set_ylabel('Loss')
ax2.grid()
ax2.legend()

<matplotlib.legend.Legend at 0x1d90e56d760>

모델 평가 및 예측

model.evaluate(x_test, y_test)

313/313 ━━━━━━━━━━━━━━━━━━━━ 0s 1ms/step - accuracy: 0.8624 - loss: 0.4657





[0.47670942544937134, 0.8607000112533569]

pred_y2 = model.predict(x_test)

print(pred_y2[0])
print(np.argmax(pred_y2[0]))

313/313 ━━━━━━━━━━━━━━━━━━━━ 0s 1ms/step
[7.7288782e-08 1.6886565e-08 5.5713816e-09 7.5809456e-09 1.1439542e-08
 3.1133941e-03 8.8125163e-10 3.7738454e-02 1.0476792e-08 9.5914805e-01]
9

arg_pred_y = np.argmax(pred_y2, axis=1)
plt.imshow(x_test[0].reshape(-1,28), cmap='gray')
plt.title(f'Predicted class : {class_names[arg_pred_y[0]]}')
plt.show()

def plot_image(i, predictions_array, true_label, img):
    predictions_array, true_label, img = predictions_array[i], true_label[i], img[i]
    plt.grid(False)
    plt.xticks([])
    plt.yticks([])

    plt.imshow(img.reshape(-1,28), cmap=plt.cm.binary)
    predicted_label = np.argmax(predictions_array)
    if predicted_label == true_label:
        color = 'blue'
    else:
        color = 'red'

    plt.xlabel(f'{class_names[predicted_label]} / {class_names[true_label]}', color=color)

def plot_value_array(i, predictions_array, true_label):
    predictions_array, true_label = predictions_array[i], true_label[i]
    plt.grid(False)
    plt.yticks([])
    plt.xticks([])
    thisplot = plt.bar(range(10), predictions_array, color="#777777")
    #thisplot = plt.bar(class_names, predictions_array, color="#777777", label=class_names)
    #plt.xticks(rotation=90)
    plt.ylim([0, 1])
    predicted_label = np.argmax(predictions_array)
    thisplot[predicted_label].set_color('red')
    thisplot[true_label].set_color('blue')

i = 0
plt.figure(figsize=(6,3))
plt.subplot(1,2,1)
plot_image(i, pred_y2, y_test, x_test)
plt.subplot(1,2,2)
plot_value_array(i, pred_y2, y_test)
plt.show()

i = 40
plt.figure(figsize=(6,3))
plt.subplot(1,2,1)
plot_image(i, pred_y2, y_test, x_test)
plt.subplot(1,2,2)
plot_value_array(i, pred_y2, y_test)
plt.show()

num_rows = 10
num_cols = 3
num_images = num_rows * num_cols

random_num = np.random.randint(10000, size=num_images)
plt.figure(figsize=(2*num_cols, num_rows))
for idx, num in enumerate(random_num):
    plt.subplot(num_rows, 2*num_cols, 2*idx+1)
    plot_image(num, pred_y2, y_test, x_test)
    plt.subplot(num_rows, 2*num_cols, 2*idx+2)
    plot_value_array(num, pred_y2, y_test)
plt.tight_layout()
plt.show()

• 혼동 행렬 (Confusion Matrix)

from sklearn.metrics import classification_report, confusion_matrix
import seaborn as sns
plt.figure(figsize=(8,8))
cm = confusion_matrix(y_test, np.argmax(pred_y2, axis=1))
sns.heatmap(cm, annot=True, fmt='d', cmap='Blues')
plt.show('True Label')
plt.show()

• 분류 보고서

print(classification_report(y_test, np.argmax(pred_y2, axis=1)))

              precision    recall  f1-score   support

           0       0.88      0.73      0.80      1000
           1       0.92      0.98      0.95      1000
           2       0.80      0.74      0.77      1000
           3       0.86      0.85      0.85      1000
           4       0.69      0.89      0.78      1000
           5       0.93      0.97      0.95      1000
           6       0.69      0.62      0.65      1000
           7       0.91      0.95      0.93      1000
           8       0.97      0.96      0.97      1000
           9       0.98      0.91      0.94      1000

    accuracy                           0.86     10000
   macro avg       0.86      0.86      0.86     10000
weighted avg       0.86      0.86      0.86     10000

ipynb 나 pdf 자료가 필요하신분은 연락주세요.

인공신경망(Artificial Neural Network)

• 인간 두뇌에 대한 계산적 모델을 통해 인공지능을 구현하려는 분야
• 인간의 뇌 구조를 모방: 뉴런과 뉴런 사이에는 전기신호를 통해 정보를 전달

생물학적 신경세포와 인공신경망 비교

• 신경세포(Neuron)

  • 수상돌기(樹狀突起, Dendrite) : 다른 신경세포의 축색돌기와 연결되어 전기화학적 신호를 받아들이는 부위
  • 축색돌기(軸索突起, Axon) : 수신한 전기화학적 신호의 합성결과 값이 특정 임계값이 이상이면 신호를 내보는 부위
  • 신경연접(神經連接, Synapse) : 수상돌기와 축색돌기 연결 부위, 전달되는 신호의 증폭 또는 감쇄

• 인공 뉴런(Artificial Neuron)

  • 신경세포 구조를 단순화하여 모델링한 구조
  • 노드(Node)와 엣지(Edge)로 표현
  • 하나의 노드안에서 입력(Inputs)와 가중치(Weights)를 곱하고 더하는 선형구조(linear)
  • 활성화 함수(activation function)를 통한 비선형 구조(non-linear) 표현 가능

• 인공 신경망(Artificial Neural Network)

  • 여러 개의 인공뉴런들이 모여 연결된 형태
  • 뉴런들이 모인 하나의 단위를 층(layer)이라고 하고, 여러 층(multi layer)으로 이루어질 수 있음
  • ex) 입력층(input layer), 은닉층(hidden layer), 출력층(output layer)

  딥러닝 프레임워크(Deep Learning Framework)

  텐서플로우(Tensorflow)

• 가장 널리 쓰이는 딥러닝 프레임워크 중 하나

• 구글이 주도적으로 개발하는 플랫폼

• 파이썬, C++ API를 기본적으로 제공하고,
  자바스크립트(JavaScript), 자바(Java), 고(Go), 스위프트(Swift) 등 다양한 프로그래밍 언어를 지원

• tf.keras를 중심으로 고수준 API 통합 (2.x 버전)

• TPU(Tensor Processing Unit) 지원

  • TPU는 GPU보다 전력을 적게 소모, 경제적
  • 일반적으로 32비트(float32)로 수행되는 곱셈 연산을 16비트(float16)로 낮춤

  케라스(Keras)

• 파이썬으로 작성된 고수준 신경망 API로 TensorFlow, CNTK, 혹은 Theano와 함께 사용 가능
• 사용자 친화성, 모듈성, 확장성을 통해 빠르고 간편한 프로토타이핑 가능
• 컨볼루션 신경망, 순환 신경망, 그리고 둘의 조합까지 모두 지원
• CPU와 GPU에서 매끄럽게 실행

딥러닝 데이터 표현과 연산

• 데이터 표현을 위한 기본 구조로 텐서(tensor)를 사용
• 텐서는 데이터를 담기위한 컨테이너(container)로서 일반적으로 수치형 데이터를 저장

텐서(Tensor)

• Rank: 축의 개수
• Shape: 형상(각 축에 따른 차원 개수)
• Type: 데이터 타입

import tensorflow as tf
import numpy as np

0D Tensor(Scalar)

• 하나의 숫자를 담고 있는 텐서(tensor)
• 축과 형상이 없음

t0 = tf.constant(1) 
print(t0)
print(tf.rank(t0)) # 축이 없는(0) 상태

1D Tensor(Vector)

• 값들을 저장한 리스트와 유사한 텐서
• 하나의 축이 존재

t1 = tf.constant([1,2,3]) 
print(t1)
print(tf.rank(t1))

2D Tensor(Matrix)

• 행렬과 같은 모양으로 두개의 축이 존재
• 일반적인 수치, 통계 데이터셋이 해당
• 주로 샘플(samples)과 특성(features)을 가진 구조로 사용

t2 = tf.constant([[1,2,3],[4,5,6],[7,8,9]]) 
print(t2)
print(tf.rank(t2))
#tf.Tensor(
#[[1 2 3]
# [4 5 6]
# [7 8 9]], shape=(3, 3), dtype=int32)
#tf.Tensor(2, shape=(), dtype=int32)

3D Tensor

• 큐브(cube)와 같은 모양으로 세개의 축이 존재
• 데이터가 연속된 시퀀스 데이터나 시간 축이 포함된 시계열 데이터에 해당
• 주식 가격 데이터셋, 시간에 따른 질병 발병 데이터 등이 존재
• 주로 샘플(samples), 타임스텝(timesteps), 특성(features)을 가진 구조로 사용

t3 = tf.constant([[[1,2,3],
                   [4,5,6],
                   [7,8,9]],
                  [[1,2,3],
                   [4,5,6],
                   [7,8,9]],
                  [[1,2,3],
                   [4,5,6],
                   [7,8,9]]]) 
print(t3)
print(tf.rank(t3)) # 축이 없는(0) 상태

output : tf.Tensor( [[[1 2 3] [4 5 6] [7 8 9]]

[[1 2 3] [4 5 6] [7 8 9]]

[[1 2 3] [4 5 6] [7 8 9]]], shape=(3, 3, 3), dtype=int32) tf.Tensor(3, shape=(), dtype=int32)

4D Tensor

• 4개의 축
• 컬러 이미지 데이터가 대표적인 사례 (흑백 이미지 데이터는 3D Tensor로 가능)
• 주로 샘플(samples), 높이(height), 너비(width), 컬러 채널(channel)을 가진 구조로 사용

5D Tensor

• 5개의 축
• 비디오 데이터가 대표적인 사례
• 주로 샘플(samples), 프레임(frames), 높이(height), 너비(width), 컬러 채널(channel)을 가진 구조로 사용

텐서 데이터 타입

• 텐서의 기본 dtype
  • 정수형 텐서: int32
  • 실수형 텐서: float32
  • 문자열 텐서: string
• int32, float32, string 타입 외에도 float16, int8 타입 등이 존재
• 연산시 텐서의 타입 일치 필요
• 타입변환에는 tf.cast() 사용

i = tf.constant(2) 
print(i)

output : tf.Tensor(2, shape=(), dtype=int32)

# tf.constant(2.)는 실수형 텐서를 생성
# 기본 dtype은 float32tf.Tensor(2.0, shape=(), dtype=float32)
i = tf.constant(2.) 
print(i)

output : tf.Tensor(2.0, shape=(), dtype=float32)

# tf.constant('ms')는 문자열 텐서를 생성
# 기본 dtype은 string
s = tf.constant('ms')
print(s) # b : 해당 문자열이 바이트(byte) 형식

output : tf.Tensor(b'ms', shape=(), dtype=string)

f16 = tf.constant(2., dtype=tf.float16)
print(f16)

output : tf.Tensor(2.0, shape=(), dtype=float16)

i8 = tf.constant(2, dtype=tf.int8) 
print(i)

output : tf.Tensor(2.0, shape=(), dtype=float32)

f32 = tf.cast(f16, tf.float32)
print(f32)

output : tf.Tensor(2.0, shape=(), dtype=float32)

i32 = tf.cast(i8, tf.int32)
print(i32)

output : tf.Tensor(2, shape=(), dtype=int32)

텐서 연산

# 텐서 연산 예제
# tf.constant()를 사용하여 상수 텐서를 생성하고 기본적인 사칙연산을 수행
# 덧셈과 뺄셈은 + 와 - 연산자 또는 tf.add()와 tf.subtract() 함수를 사용할 수 있음
print(tf.constant(2) + tf.constant(2))
print(tf.constant(2) - tf.constant(2))
print(tf.add(tf.constant(2) , tf.constant(2)))
print(tf.subtract(tf.constant(2) , tf.constant(2)))

output : tf.Tensor(4, shape=(), dtype=int32) tf.Tensor(0, shape=(), dtype=int32) tf.Tensor(4, shape=(), dtype=int32) tf.Tensor(0, shape=(), dtype=int32)

print(tf.constant(2) * tf.constant(2))
print(tf.constant(2) / tf.constant(2))
print(tf.multiply(tf.constant(2) , tf.constant(2)))
print(tf.divide(tf.constant(2) , tf.constant(2)))

output : print(tf.constant(2) * tf.constant(2)) print(tf.constant(2) / tf.constant(2)) print(tf.multiply(tf.constant(2) , tf.constant(2))) print(tf.divide(tf.constant(2) , tf.constant(2)))

# print(tf.constant(2) + tf.constant(2.2)) # 에러남
print(tf.cast(tf.constant(2),tf.float32) + tf.constant(2.2))

output : tf.Tensor(4.2, shape=(), dtype=float32)

딥러닝 구조 및 학습

• 딥러닝 구조와 학습에 필요한 요소
  • 모델(네트워크)를 구성하는 레이어(layer)
  • 입력 데이터와 그에 대한 목적(결과)
  • 학습시에 사용할 피드백을 정의하는 손실 함수(loss function)
  • 학습 진행 방식을 결정하는 옵티마이저(optimizer)

레이어(Layer)

• 신경망의 핵심 데이터 구조
• 하나 이상의 텐서를 입력받아 하나 이상의 텐서를 출력하는 데이터 처리 모듈
• 상태가 없는 레이어도 있지만, 대부분 가중치(weight)라는 레이어 상태를 가짐
• 가중치는 확률적 경사 하강법에 의해 학습되는 하나 이상의 텐서

• Keras에서 사용되는 주요 레이어
  • Dense
  • Activation
  • Flatten
  • Input

https://www.securityinfowatch.com/video-surveillance/video-analytics/article/21069937/deep-learning-to-the-rescue

# tensorflow.keras.layers에서 주요 레이어들을 import
# Dense: 완전연결계층을 구현하는 레이어
# Activation: 활성화 함수를 적용하는 레이어  
# Flatten: 다차원 입력을 1차원으로 펼치는 레이어
# Input: 모델의 입력을 정의하는 레이어
from tensorflow.keras.layers import Dense, Activation, Flatten, Input

Dense

• 완전연결계층(Fully-Connected Layer)

• 노드수(유닛수), 활성화 함수(activation) 등을 지정

• name을 통한 레이어간 구분 가능

• 가중치 초기화(kernel_initializer)

  • 신경망의 성능에 큰 영향을 주는 요소
  • 보통 가중치의 초기값으로 0에 가까운 무작위 값 사용
  • 특정 구조의 신경망을 동일한 학습 데이터로 학습시키더라도, 가중치의 초기값에 따라 학습된 신경망의 성능 차이가 날 수 있음
  • 오차역전파 알고리즘은 기본적으로 경사하강법을 사용하기 때문에 최적해가 아닌 지역해에 빠질 가능성이 있음
  • Keras에서는 기본적으로 Glorot uniform 가중치(Xavier 분포 초기화), zeros bias로 초기화
  • kernel_initializer 인자를 통해 다른 가중치 초기화 지정 가능
  • Keras에서 제공하는 가중치 초기화 종류: https://keras.io/api/layers/initializers/

# 아래 레이어를 통과하면 결과로 10개의 출력 노드가 생성됨.
# Dense 레이어는 이전 레이어의 출력이 어떤 크기든 간에 
# 이를 받아들여 내부적으로 적절히 처리하고 10개의 출력을 생성
# 레이어를 정의할 때 입력 노드의 수를 명시적으로 지정할 필요는 없음.

Dense(10, activation='softmax')
Dense(10, activation='relu', name='Dense Layer')
Dense(10, kernel_initializer='he_normal', name='Dense Layer')

Activation

• Dense layer에서 미리 활성화 함수를 지정할 수도 있지만 필요에 따라 별도 레이어를 만들어줄 수 있음
• Keras에서 제공하는 활성화 함수(activation function) 종류: https://keras.io/ko/activations/

# 사용 예시
dense = Dense(10,activation='relu',name='Dense Layer')
Activation(dense)

Flatten

• 배치 크기(또는 데이터 크기)를 제외하고 데이터를 1차원으로 쭉 펼치는 작업
• 예시)

    (128, 3, 2, 2) -> (128, 12)

# 전체 출력은 (batch_size, height * width * channels) 형태를 가짐. 
# 여기서 첫 번째 차원은 배치 크기를 나타내고, 두 번째 차원은 평탄화된 피처를 나타냄.
# 따라서, Flatten 레이어의 출력 텐서는 랭크가 2인 2D 텐서임.
flatten = Flatten(input_shape=(128,3,2,2))

### Input

- 모델의 입력을 정의
- `shape`, `dtype`을 포함
- 하나의 모델은 여러 개의 입력을 가질 수 있음
- `summary()` 메소드를 통해서는 보이지 않음

# None: 이 위치의 None은 배치 크기(batch size)를 나타냅니다.
# None이 사용된 이유는 배치 크기가 미리 정의되지 않았고,
# 모델을 실행할 때 어떤 배치 크기도 사용될 수 있음을 의미함.
# 즉, 입력 데이터의 총 수는 가변적이며, 실제 모델 훈련이나 추론시에 결정됩니다.

Input(shape=(8,), dtype=tf.int32)

모델(Model)

• 딥러닝 모델은 레이어로 만들어진 비순환 유향(방향이 있는) 그래프(Directed Acyclic Graph, DAG) 구조

모델 구성

• Sequential()
• 서브클래싱(Subclassing) - 클래스를 상속받아서 하는 방법
• 함수형 API

Sequential()

• 모델이 순차적인 구조로 진행할 때 사용
• 간단한 방법
  • Sequential 객체 생성 후,add()를 이용한 방법
  • Sequential 인자에 한번에 추가 방법
• 다중 입력 및 출력이 존재하는 등의 복잡한 모델을 구성할 수 없음

from tensorflow.keras.layers import Dense, Input, Flatten
from tensorflow.keras.models import Sequential, Model
from tensorflow.keras.utils import plot_model

model = Sequential()
model.add(Input(shape=(28,28)))
model.add(Dense(300, activation='relu'))
model.add(Dense(100, activation='relu'))
model.add(Dense(10, activation='softmax'))
model.summary()

output :

Param = 가중치(weight, biases)의 총 수 가중치의 총 수 = (입력 유닛 수) x (출력 유닛 수) 바이어스의 총 수 = 출력 유닛 수(각 출력 유닛마다 하나의 바이어스가 있음) 총 파라미터 수 = 가중치의 총 수 + 바이어스의 총 수

dense_4 = 28300+300 dense_5 = 300100+100 dense_6 = 100*10+10

#!pip install pydot
plot_model(model)

model = Sequential([
    Input(shape=(28,28)),
    Dense(300, activation='relu'),
    Dense(100, activation='relu'),
    Dense(10, activation='softmax')])
model.summary()

함수형 API

• 가장 권장되는 방법(sequential은 단순하게 순차적으로 쌓이는 구조에서만 동작 가능)
• 모델을 복잡하고, 유연하게 구성 가능
• 다중 입출력을 다룰 수 있음

inputs = Input(shape=(28,28,1))
x = Flatten(input_shape=(28,28,1))(inputs)
x = Dense(300,activation='relu')(x)
x = Dense(100,activation='relu')(x)
x = Dense(10,activation='softmax')(x)

model = Model(inputs=inputs, outputs=x)
model.summary()

plot_model(model)

# 복잡한 모델
from tensorflow.keras.layers import Concatenate

input_layer = Input(shape=(28,28))
hidden1 = Dense(100, activation='relu')(input_layer)
hidden2 = Dense(30, activation='relu')(hidden1)
concat = Concatenate()([input_layer, hidden2])
output = Dense(1)(concat)

model = Model(inputs=[input_layer], outputs=[output])
model.summary()

plot_model(model)

# input 두개인 모델
input_1 = Input(shape=(10,10))
input_2 = Input(shape=(10,28))

hidden1 = Dense(100, activation='relu')(input_2)
hidden2 = Dense(10, activation='relu')(hidden1)
concat = Concatenate()([input_1, hidden2])

output = Dense(1, activation='sigmoid')(concat)
model = Model(inputs=[input_1, input_2], outputs=[output])
model.summary()

plot_model(model)

# input 두개인 모델
input_ = Input(shape=(10,10), name = 'input_')

hidden1 = Dense(100, activation='relu')(input_)
hidden2 = Dense(10, activation='relu')(hidden1)

output = Dense(1, activation='sigmoid', name='main_output')(hidden2)
sub_output = Dense(1, name='sub_output')(hidden2)

model = Model(inputs=[input_], outputs=[output, sub_output])
model.summary()

plot_model(model)

# input, output 둘 다 두개인 모델
input_1 = Input(shape=(10,10))
input_2 = Input(shape=(10,28))

hidden1 = Dense(100, activation='relu')(input_2)
hidden2 = Dense(10, activation='relu')(hidden1)
concat = Concatenate()([input_1, hidden2])

output = Dense(1, activation='sigmoid',name='main_output')(concat)
sub_out = Dense(1,name='sub_output')(hidden2)

model = Model(inputs=[input_1, input_2], outputs=[output, sub_out])
model.summary()

plot_model(model ,show_layer_names=True, show_shapes=True)

#### 서브클래싱(Subclassing)

- 커스터마이징에 최적화된 방법
- 이미 어느정도 만들어진걸 조금 수정하여 재활용하는 느낌
- Model 클래스를 상속받아 Model이 포함하는 기능을 사용할 수 있음  
  - `fit()`, `evaluate()`, `predict()`
  - `save()`, `load()`
- 주로 `call()` 메소드안에서 원하는 계산 가능
  - for, if, 저수준 연산 등
- 권장되는 방법은 아니지만 어떤 모델의 구현 코드를 참고할 때, 해석할 수 있어야함

모델 가중치 확인

class MyModel(Model):
    def __init__(self, units=30, activation='relu',**kwargs):
        # Model class의 생성자 실행. Model class에 정의된 value 속성도 초기화
        super(MyModel, self).__init__(**kwargs)
        #super().__init__(**kwargs) # 이렇게 가능
        self.dense_layer1 = Dense(300, activation=activation)
        self.dense_layer2 = Dense(100, activation=activation)
        self.dense_layer3 = Dense(units, activation=activation)
        self.output_layer = Dense(10, activation='softmax')

    def call(self, inputs):
        x = self.dense_layer1(x)
        x = self.dense_layer2(x)
        x = self.dense_layer3(x)
        x = self.output_layer(x)
        return x

model = MyModel()
# 참고
# def abc(**kwargs):
#     print(kwargs)
# abc(a=3, b='c') # {'a': 3, 'b': 'c'}

inputs = Input(shape=(28,28,1))
x = Flatten(input_shape=(28,28,1))(inputs)
x = Dense(300, activation='relu')(x)
x = Dense(100, activation='relu')(x)
x = Dense(10, activation='softmax')(x)

model = Model(inputs=inputs, outputs = x)
model.summary()

model.layers

output:
[<InputLayer name=input_layer_26, built=True>,
 <Flatten name=flatten_5, built=True>,
 <Dense name=dense_73, built=True>,
 <Dense name=dense_74, built=True>,
 <Dense name=dense_75, built=True>]

hidden_2 = model.layers[2]
hidden_2.name

output : 'dense_73'

# 가져온 모델 맞는지 검증하기
model.get_layer('dense_73') == hidden_2

output : True

# 레이어의 weight, bias 확인하기
weights, biases = hidden_2.get_weights()
print(weights.shape)
print(biases.shape)

output : (784, 300) (300,)

print(weights)

output: [[-0.0189958 0.04178642 -0.02973261 ... 0.02392814 -0.06515371 -0.01094473] [-0.06765752 0.05939554 0.05841401 ... -0.03066007 0.07289664 0.03665416] [ 0.02429469 0.06326848 0.03675973 ... -0.06022335 0.03570367 0.04572336] ... [ 0.03738911 0.0086766 -0.05104835 ... 0.03970996 -0.00280691 -0.06960735] [ 0.06139068 0.00252346 -0.00775075 ... 0.05078986 -0.03957617 0.0160888 ] [ 0.06548205 0.01272491 -0.05994889 ... -0.05388444 0.06571051 -0.02650245]]

print(biases)

output: [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]

### 모델 컴파일(compile)
#- 모델을 구성한 후, 사용할 손실 함수(loss function), 옵티마이저(optimizer)를 지정
model.compile(loss = 'sparse_categorical_crossentropy',
              optimizer='sgd',
              metrics = ['accuracy'])

손실 함수(Loss Function)

• 학습이 진행되면서 해당 과정이 얼마나 잘 되고 있는지 나타내는 지표
• 모델이 훈련되는 동안 최소화될 값으로 주어진 문제에 대한 성공 지표
• 손실 함수에 따른 결과를 통해 학습 파라미터를 조정
• 최적화 이론에서 최소화 하고자 하는 함수
• 미분 가능한 함수 사용
• Keras에서 주요 손실 함수 제공
  • sparse_categorical_crossentropy: 클래스가 배타적 방식으로 구분, 즉 (0, 1, 2, ..., 9)와 같은 방식으로 구분되어 있을 때 사용
  • categorical_cross_entropy: 클래스가 원-핫 인코딩 방식으로 되어 있을 때 사용
  • binary_crossentropy: 이진 분류를 수행할 때 사용

평균절대오차(Mean Absolute Error, MAE)

• 오차가 커져도 손실함수가 일정하게 증가
• 이상치(Outlier)에 강건함(Robust)
  • 데이터에서 [입력 - 정답] 관계가 적절하지 않은 것이 있을 경우에, 좋은 추정을 하더라도 오차가 발생하는 경우가 발생
  • 해당 이상치에 해당하는 지점에서 손실 함수의 최소값으로 가는 정도의 영향력이 크지 않음
• 회귀 (Regression)에 많이 사용
• 평균절대오차 식: $ \qquad \qquad E = \frac{1}{n}\sum_{i=1}^n \left | y_i - \tilde{y}_i \right |$
  • $y_i$ : 학습 데이터의 $i\ $번째 정답
  • $\tilde{y}_i$ : 학습 데이터의 입력으로 추정한 $i\ $번째 출력

평균제곱오차(Mean Squared Error, MSE)

• 가장 많이 쓰이는 손실 함수 중 하나
• 오차가 커질수록 손실함수가 빠르게 증가
  • 정답과 예측한 값의 차이가 클수록 더 많은 페널티를 부여
• 회귀 (Regression)에 쓰임
• 평균제곱오차 식: $ \qquad \qquad E = \frac{1}{n}\sum_{i=1}^n ( y_i - \tilde{y}_i)^2 $
  • $y_i$ : 학습 데이터의 $i\ $번째 정답
  • $\tilde{y}_i$ : 학습 데이터의 입력으로 추정한 $i\ $번째 출력

손실함수 MAE와 MSE 비교

원-핫 인코딩(One-Hot Encoding)

• 범주형 변수를 표현할 때 사용
• 가변수(Dummy Variable)이라고도 함
• 정답인 레이블을 제외하고 0으로 처리

교차 엔트로피 오차(Cross Entropy Error, CEE)

• 이진 분류(Binary Classification), 다중 클래스 분류(Multi Class Classification)
• 소프트맥스(softmax)와 원-핫 인코딩(ont-hot encoding) 사이의 출력 간 거리를 비교
• 정답인 클래스에 대해서만 오차를 계산
• 정답을 맞추면 오차가 0, 틀리면 그 차이가 클수록 오차가 무한히 커짐
• $y = log(x)$
  • $x$가 1에 가까울수록 0에 가까워짐
  • $x$가 0에 가까울수록 $y$값은 무한히 커짐

• 교차 엔트로피 오차 식: $ \qquad \qquad E = - \frac{1}{N}\sum_{n} \sum_{i} y_i\ log\tilde{y}_i $

  • $y_i$ : 학습 데이터의 $i\ $번째 정답 (원-핫 인코딩, one-hot encoding)
  • $\tilde{y}_i$ : 학습 데이터의 입력으로 추정한 $i\ $번째 출력
  • $N$ : 전체 데이터의 개수
  • $i$ : 데이터 하나당 클래스 개수

• 정답 레이블($y_i$)은 원-핫 인코딩으로 정답인 인덱스에만 1이고, 나머지는 모두 0이라서 다음과 같이 나타낼 수 있음

  $ \qquad \qquad E = - log\tilde{y}_i $

  • 소프트맥스를 통해 나온 신경망 출력이 0.6이라면 $\ -log0.6 \fallingdotseq -0.51\ $이 되고, 신경망 출력이 0.3이라면 $\ -log0.3 \fallingdotseq -1.2\ $이 됨
  • 정답에 가까워질수록 오차값은 작아짐
  • 학습시, 원-핫 인코딩에 의해 정답 인덱스만 살아 남아 비교하지만, 정답이 아닌 인덱스들도 학습에 영향을 미침. 왜냐하면 다중 클래스 분류는 소프트맥스(softmax) 함수를 통해 전체 항들을 모두 다루기 때문

이진 분류 문제의 교차 크로스 엔트로피(Binary Cross Entropy, BCE)

• 이진 분류 문제(Binary Classification Problem)에서도 크로스 엔트로피 오차를 손실함수로 사용 가능 $ \qquad \qquad E = - \sum_{i=1}^2 y_i\ log\tilde{y}_i \ \qquad \qquad \ \ \ = -y_1\ log\ \tilde{y}_1 - (1 - y_1)log(1-\ \tilde{y}_1) $
  $\qquad \qquad \qquad ( \because y_2 = 1 - y_1)$
  • $y_i$ : 학습 데이터의 $i\ $번째 정답 (원-핫 인코딩, one-hot encoding)
  • $\tilde{y}_i$ : 학습 데이터의 입력으로 추정한 $i\ $번째 출력

옵티마이저(Optimizer)

• 손실 함수를 기반으로 모델이 어떻게 업데이트되어야 하는지 결정 (특정 종류의 확률적 경사 하강법 구현)
• Keras에서 여러 옵티마이저 제공
  • keras.optimizer.SGD(): 기본적인 확률적 경사 하강법
  • keras.optimizer.Adam(): 자주 사용되는 옵티마이저
  • Keras에서 사용되는 옵티마이저 종류: https://keras.io/ko/optimizers/
• 보통 옵티마이저의 튜닝을 위해 따로 객체를 생성하여 컴파일

볼록함수(Convex Function)와 비볼록함수(Non-Convex Function)

• 볼록함수(Convex Function)
  • 어떤 지점에서 시작하더라도 최적값(손실함수가 최소로하는 점)에 도달할 수 있음
• 비볼록함수(Non-Convex Function)
  • 비볼록 함수는 시작점 위치에 따라 다른 최적값에 도달할 수 있음

경사하강법(Gradient Decent)

• 미분과 기울기
  • 스칼라를 벡터로 미분한 것(스칼라 함수의 각 변수에 대한 변미분값들을 모아둔 리스트, 즉 그라디언트 벡터를 의미)
  • 그라디언트 벡터 ∇f(x)=[ f'(x1), f'(x2), f'(x3)]
  • w new =w−η⋅∇L(w) 예시) 기존 가중치 벡터[0,0,0,0,0], 그라디언트벡터[1,2,3,4,5], 업데이트후 [-1,-2,-3,-4,-5]

$\quad \frac{df(x)}{dx} = \lim_{\triangle x \to 0} \frac{f(x+\triangle x) - f(x)}{\triangle x}$

$\quad \triangledown f(x) = \left( \frac{\partial f}{\partial x_1}, \frac{\partial f}{\partial x_2},\ ... \ , \frac{\partial f}{\partial x_N} \right)$

• 변화가 있는 지점에서는 미분값이 존재하고, 변화가 없는 지점은 미분값이 0

• 미분값이 클수록 변화량이 크다는 의미

  • 경사하강법의 과정
  • 경사하강법은 한 스텝마다의 미분값에 따라 이동하는 방향을 결정
  • $f(x)$의 값이 변하지 않을 때까지 반복

  $\qquad x_n = x_{n-1} - \eta \frac{\partial f}{\partial x}$

  • $\eta$ : 학습률(learning rate)
  • 즉, 미분값이 0인 지점을 찾는 방법

학습률(learning rate)

• 적절한 학습률을 지정해야 최저점에 잘 도달할 수 있음
• 학습률이 너무 크면 발산하고, 너무 작으면 학습이 오래 걸리거나 최저점에 도달하지 않음

안장점(Saddle Point)

• 기울기가 0이지만 극값이 되지 않음
• 경사하강법은 안장점에서 벗어나지 못함

지표(Metrics)

• 모니터링할 지표
• mae나 accuracy 사용
• 줄여서 acc로도 사용 가능
• Keras에서 사용되는 지표 종류: https://keras.io/ko/metrics/

모델 학습, 평가 및 예측

• fit()

  • x: 학습 데이터
  • y: 학습 데이터 정답 레이블
  • epochs: 학습 회수
  • batch_size: 단일 배치에 있는 학습 데이터의 크기
  • validation_data: 검증을 위한 데이터

• evaluate()

  • 테스트 데이터를 이용한 평가

• predict()

  • 임의의 데이터를 사용해 예측

  오차역전파 (Backpropagation)

• 오차역전파 알고리즘

  • 학습 데이터로 정방향(forward) 연산을 통해 손실함수 값(loss)을 구함
  • 각 layer별로 역전파학습을 위해 중간값을 저장
  • 손실함수를 학습 파라미터(가중치, 편향)로 미분하여 마지막 layer로부터 앞으로 하나씩 연쇄법칙을 이용하여 미분
  • 각 layer를 통과할 때마다 저장된 값을 이용
  • 오류(error)를 전달하면서 학습 파라미터를 조금씩 갱신

• 오차역전파 학습의 특징

  • 손실함수를 통한 평가를 한 번만 하고, 연쇄법칙을 이용한 미분을 활용하기 때문에 학습 소요시간이 매우 단축
  • 미분을 위한 중간값을 모두 저장하기 때문에 메모리를 많이 사용

• 신경망 학습에 있어서 미분가능의 중요성

  • 경사하강법(Gradient Descent)에서 손실 함수(cost function)의 최소값, 즉, 최적값을 찾기 위한 방법으로 미분을 활용
  • 미분을 통해 손실 함수의 학습 매개변수(trainable parameter)를 갱신하여 모델의 가중치의 최적값을 찾는 과정

• 합성함수의 미분 (연쇄법칙, chain rule)

  $\qquad \frac{d}{dx} [f(g(x))] = f^\prime(g(x))g^\prime(x)$

  • 여러개를 연속으로 사용 가능

  $ \quad \frac{\partial f}{\partial x} = \frac{\partial f}{\partial u} \times \frac{\partial u}{\partial m} \times \frac{\partial m}{\partial n} \times \ ... \ \frac{\partial l}{\partial k} \times \frac{\partial k}{\partial g} \times \frac{\partial g}{\partial x} $

  • 각각에 대해 *편미분 적용가능
  • 편미분 : 다변수 함수에서 하나의 변수를 제외한 나머지 변수들을 상수로 취급하고, 해당 변수에 대해서만 미분을 수행하는 것

• 오차역전파의 직관적 이해

  • 학습을 진행하면서, 즉 손실함수의 최소값(minimum)을 찾아가는 과정에서 가중치 또는 편향의 변화에 따라 얼마나 영향을 받는지 알 수 있음

회사를 그만두고 프리랜서 개발자로 활동하며, 출장이 잦아 집이 아닌 장소에서 개발하는 일이 많아졌습니다. 특히 GPU를 활용한 작업이 필요할 때가 있는데, GPU가 탑재된 노트북은 무겁고 휴대성이 떨어지기 때문에 집에 우분투(Ubuntu) 기반의 데스크톱을 구축하여 원격으로 작업하는 방법을 선택했습니다.

문제점

집에서 작업할 때는 내부 네트워크(사설 IP)를 이용하여 원격 접속이 가능하지만, 외부에서는 내부 IP에 직접 접근할 수 없기 때문에 공인 IP를 통해 원격 접속을 해야 합니다. 그러나 공인 IP를 외부에서 접근할 수 있도록 개방하면 보안 취약점이 발생합니다.

보안 위험 요소:

• 공개된 SSH 포트 → 자동화된 공격(Brute-force, Dictionary Attack) 대상이 될 가능성이 큼.
• 포트 스캐닝 → 해커가 특정 포트를 통해 원격 접근을 시도할 위험이 있음.
• DDoS 공격 위험 → 공인 IP가 알려지면 네트워크 공격 대상이 될 가능성이 있음.

대안: VPN을 활용한 원격 접속

VPN을 사용하면 외부 네트워크에서도 집 내부 네트워크에 연결된 것처럼 동작할 수 있습니다. 즉, 집에서 내부 IP(사설 IP)로만 접근 가능한 장치에도 외부에서 안전하게 접근할 수 있게 됩니다.

따라서 VPN을 쓰기 위해 여러 VPN 서비스에 대해 알아보았습니다. 비용을 지불하고 편리하게 사용할 수 있는 VPN, 직접 설치하여 쓰는 오픈소스 VPN 등이 있었는데, 최신 기술이 적용된 WireGuard가 설정이 간편하면서도 성능이 뛰어나므로 WireGuard를 사용하여 직접 VPN 서버를 구축하기로 결정하게 되었습니다.

설치 및 설정 과정

우선, WireGuard 서버가 실행될 우분투 시스템의 사설 IP(내부 IP)를 고정해야 합니다. (라우터에서 내부 IP를 DHCP로 자동 할당하면 변경될 수 있기 때문에 고정 설정이 필요합니다.)

1. 내부 IP 확인

ip addr show

1-2. 출력 예시

2: enp5s0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500
    inet 192.168.45.177/24 brd 192.168.45.255 scope global dynamic enp5s0

2. 내부 IP 고정 설정 방법

2-1. 네트워크 설정 파일 접근

• 저의 경우는 /etc/netplan/01-network-manager-all.yaml 경로에 네트워크 설정파일이 위치하고 있습니다.

  sudo nano /etc/netplan/01-network-manager-all.yaml

2-2. 내용 수정

• 아래 캡쳐된 이미지처럼 사용할 IP를 사설IP 대역에서 설정해주시면 됩니다.
• 간략히 아래 이미지에 대해 설명드리면
  • dhcp4: no -> 자동할당 비활성화(고정 ip 사용)
  • gateway4 -> 라우터(공유기 IP)
  • address(192.168.45.177/24) -> 고정 ip 설정 24는 네트워크와 호스트를 구분하는 범위를 알려줍니다.
  • 총 32비트(4바이트) 숫자에서 네트워크 부분이 24비트, 호스트 부분이 8비트임을 나타냅니다. 따라서 뒤의 8비트 부분의 숫자를 다르게 하여 192.168.45.1 ~ 192 168.45.254 범위의 IP를 실제 장치에 할당할 수 있습니다.
  • nameservers -> DNS 서버 설정 (라우터 및 Google DNS)

2-3. 설정 적용

이후 아래 명령어를 통해 변경사항을 적용하면 됩니다. 이제 내부 네트워크에서 192.168.45.177을 항상 유지할 수 있습니다

sudo netplan apply

3. wireguard 설치

WireGuard 서버를 우분투에 설치하는 방법은 여러 가지가 있지만, 설정을 간편하게 하기 위해 Docker 컨테이너를 이용하여 설치합니다.

컨테이너를 만들기 위한 도커 이미지는 도커 허브에서 검색하여 쉽게 다운받을 수 있습니다. 아래 링크를 참조하여 도커 허브에서 이미지를 다운받습니다.

공식 이미지 링크 : https://hub.docker.com/r/linuxserver/wireguard 도커 이미지 다운로드 명령어:

docker pull linuxserver/wireguard

4. 포트 포워딩 설정

특정 아이피와 포트 설정을 진행합니다.

외부 포트 시작과 끝은 외부에서 접속할 같은 포트 번호로 작성해주면 됩니다. 내부 ip는 wireguard가 실행되 컴퓨터의 사설(내부)IP로 설정하고 내부 포트 시작 및 끝은 wireguard가 수신하는 포트번호입니다. 마찬가지로 같은 값으로 설정하면 되고 기본값은 51820 입니다. 내부 ip는 위에서 설정해준 값으로 하시면 됩니다. 어려우시면 1,2,3,4 모두 51820 으로 하셔도 괜찮습니다. 설정 후 외부에서 nmap이라는 프로그램을 설치하시거나 터미널 명령어를 사용해서 해당 포트가 잘 열려있는지 체크해줍니다. 명령어는 다음과 같습니다.

sudo nmap -sU -p 51820 <공인IP> # 우분투 명령어

우분투 방화벽을 사용하는 경우 아래 명령어를 사용하여 UDP 포트를 열어야합니다.

sudo ufw allow 51820/udp
sudo ufw enable

5. WireGuard 컨테이너 실행

네트워크 설정이 완료되었으면, 다운받은 wireguard 이미지를 이용해 컨테이너를 생성하고 해당 컨테이너에서 설정을 마무리해줍니다. 저는 아래의 명령어를 이용해 컨테이너를 만들었습니다.

docker run -d \
  --name=wireguard \
  --cap-add=NET_ADMIN \
  -e SERVERURL=<공인IP> \
  -e SERVERPORT=51820 \
  -p 51820:51820/udp \
  -v /path/to/wireguard/config:/config \
  --restart unless-stopped \
  lscr.io/linuxserver/wireguard:latest

• SERVERURL: 공인 IP 또는 DDNS 주소 입력
• SERVERPORT: 51820 (기본값)
• -p 51820:51820/udp: 포트 포워딩 적용

컨테이너가 만들어졌으면, 해당 컨테이너로 접속합니다.

docker exec -it wireguard bash

이후 wireguard 설정 파일로 진입합니다.

vi /config/wg_confs/wg0.conf

항목 중에서 ListenPort가 설정한 외부포트로 설정되어있는지 확인합니다.

이후 /config/peer1 경로에 접속하여 아래 두 파일을 다운로드 합니다.

• peer1.conf 파일을 WireGuard 클라이언트에 등록
• peer1.png 파일(QR코드)을 모바일에서 WireGuard 앱으로 스캔하여 연결 가능

윈도우의 경우 wireguard 클라이언트 파일을 받아 peer1.conf 파일을 업로드하면 VPN 연결이 활성화되는 것을 확인할 수 있었습니다.

하루 정도만 투자하면 무료로 안전한 원격 작업 환경을 구축할 수 있으니, 저와 비슷한 상황이신 분들은 한번쯤 사용해보시길 권장드립니다.

[이미지 출처] https://www.researchgate.net/figure/Q-Learning-vs-Deep-Q-Learning_fig1_351884746

핵심 개념

• Q-함수: 상태-행동 가치 함수라고도 불리며 상태(s)에서 행동(a)을 취했을 때의 예상 가치를 리턴하는 함수. 벨만 방정식을 기반으로 Q값을 갱신함

• 벨만 방정식: Q(s,a) = r + γ * max(Q(s',a'))

  • Q($s_t$,$a_t$) : 현재 상태 $s_t$에서 행동$a_t$를 했을 때 기대되는 누적 보상
  • r: 즉각적인 보상
  • γ: 할인 계수
  • s': 다음 상태
  • a': 다음 상태에서 가능한 모든 행동

• Q-함수 업데이트 식:

  • $$ Q(s_t, a_t) \leftarrow (1-\alpha)Q(s_t, a_t) + \alpha \big(r + \gamma \max_{a'} Q(s_{t+1}, a') - Q(s_t, a_t)\big) $$
  • $\alpha$: 학습률 (0~1 사이의 값으로, 새로운 정보의 반영 정도를 조절)
  • 업데이트는 현재 $Q(s_t, a_t)$ 값을 보상과 다음 상태의 최댓값을 반영하여 조금씩 개선하는 방식으로 진행됩니다.

• ε-greedy 정책: 탐험(exploration)과 활용(exploitation)의 균형을 위한 정책

  • Exploration (탐험): 아직 시도해보지 않은 행동을 선택하여 더 나은 보상을 찾는 과정.새로운 정보를 얻을 수 있지만, 단기적으로는 보상이 낮을 수 있음.

  • Exploitation (활용): 이미 알고 있는 정보에서 가장 높은 보상을 줄 것이라고 예상되는 행동을 선택. 현재의 지식으로 최대 보상을 얻으려는 접근. ε-Greedy 정책은 이 두 과정을 아래와 같은 방식으로 혼합합니다:

  • 확률 ε로 랜덤하게 행동을 선택(탐험).확률 (1−𝜀)로 현재 가장 높은 보상을 줄 것으로 예상되는 행동 선택(활용)

알고리즘 단계

1. Q-테이블 초기화
2. 현재 상태 관찰
3. ε-greedy 정책에 따라 행동 선택
4. 행동 수행 및 보상 획득
5. Q-함수 업데이트
6. 새로운 상태로 이동
7. 2-6 단계 반복

장단점

장점:

• 모델 없이 학습 가능 (모델 프리 접근법)
• 학습 종료 시 수렴성 보장

단점:

• 큰 상태 공간에서는 비효율적
• 연속적인 상태나 행동 처리에 제한
  • 1. 메모리 요구량 증가 : 큰 상태 공간에서는 Q-테이블의 크기가 기하급수적으로 증가합니다. 각 상태-행동 쌍에 대한 Q-값을 저장해야 하므로, 상태의 수가 증가할수록 필요한 메모리가 급격히 늘어납니다.
  • 2. 학습 시간 증가 : 상태 공간이 커질수록 모든 상태-행동 쌍을 충분히 탐색하고 Q-값을 업데이트하는 데 필요한 시간이 크게 증가합니다. 이는 학습 속도를 현저히 저하시킵니다.
  • 3. 탐색-활용 딜레마 : 큰 상태 공간에서는 모든 상태를 충분히 탐색하기 어려워집니다. 이로 인해 최적 정책을 찾는 데 필요한 탐색과 학습된 정책을 활용하는 것 사이의 균형을 맞추기가 더욱 어려워집니다.

코드 설명

제공된 코드는 Q-Learning을 구현한 예제입니다. Env 클래스는 그리드 월드 환경을, QLearningAgent 클래스는 Q-Learning 에이전트를 구현합니다.

주요 함수 설명

1. Env 클래스:

   • __init__: 환경 초기화
   • step: 행동 수행 및 다음 상태, 보상 반환
   • reset: 환경 초기화

2. QLearningAgent 클래스:

   • learn: Q-함수 업데이트
   • get_action: ε-greedy 정책에 따른 행동 선택

코드 실행 과정

1. 환경과 에이전트 초기화
2. 에피소드 반복:
   • 상태 초기화
   • 행동 선택 및 수행
   • Q-함수 업데이트
   • 새로운 상태로 이동
   • Q-값 출력
3. 1000 에피소드 동안 반복

이 코드를 통해 에이전트는 그리드 월드에서 장애물을 피해 목표에 도달하는 최적 경로를 학습합니다.

• 아래 코드는 코랩 환경이 아닌 로컬 파이썬 환경에서 진행해주세요!
• 코드 출처 : https://github.com/rlcode/reinforcement-learning-kr

# 필요한 라이브러리 임포트
import time  # 딜레이를 추가하거나 시간 측정을 위해 사용
import numpy as np  # 배열 및 수학적 계산에 사용
import tkinter as tk  # GUI 환경을 구성하기 위한 라이브러리
from PIL import ImageTk, Image  # 이미지를 tkinter에서 사용하기 위해 변환

# 랜덤 시드 설정 (재현 가능성 보장)
np.random.seed(1)

# tkinter에서 사용할 이미지 객체
PhotoImage = ImageTk.PhotoImage

# 그리드월드 크기 설정
UNIT = 100  # 각 셀의 크기 (픽셀)
HEIGHT = 5  # 그리드월드의 세로 크기 (셀 단위)
WIDTH = 5  # 그리드월드의 가로 크기 (셀 단위)


class Env(tk.Tk):
    def __init__(self):
        # tkinter의 Tk 클래스를 초기화
        super(Env, self).__init__()
        # 환경에서 사용할 행동들 (상, 하, 좌, 우)
        self.action_space = ['u', 'd', 'l', 'r']
        self.n_actions = len(self.action_space)  # 행동의 개수
        self.title('Q Learning')  # 윈도우 제목
        self.geometry('{0}x{1}'.format(HEIGHT * UNIT, HEIGHT * UNIT))  # 윈도우 크기
        self.shapes = self.load_images()  # 사용할 이미지 로드
        self.canvas = self._build_canvas()  # 캔버스 초기화
        self.texts = []  # 그리드 안에 텍스트 표시를 위한 리스트

    def _build_canvas(self):
        # 캔버스 생성 (그리드 및 이미지 추가)
        canvas = tk.Canvas(self, bg='white',
                           height=HEIGHT * UNIT,
                           width=WIDTH * UNIT)
        # 세로선 그리기
        for c in range(0, WIDTH * UNIT, UNIT):
            x0, y0, x1, y1 = c, 0, c, HEIGHT * UNIT
            canvas.create_line(x0, y0, x1, y1)
        # 가로선 그리기
        for r in range(0, HEIGHT * UNIT, UNIT):
            x0, y0, x1, y1 = 0, r, HEIGHT * UNIT, r
            canvas.create_line(x0, y0, x1, y1)

        # 캔버스에 이미지 추가
        self.rectangle = canvas.create_image(50, 50, image=self.shapes[0])  # 빨간 네모 (에이전트)
        self.triangle1 = canvas.create_image(250, 150, image=self.shapes[1])  # 장애물1
        self.triangle2 = canvas.create_image(150, 250, image=self.shapes[1])  # 장애물2
        self.circle = canvas.create_image(250, 250, image=self.shapes[2])  # 목표 지점

        canvas.pack()  # 캔버스를 tkinter 윈도우에 추가
        return canvas

    def load_images(self):
        # 이미지를 로드하고 크기를 조정하여 반환
        rectangle = PhotoImage(
            Image.open("../img/rectangle.png").resize((65, 65)))
        triangle = PhotoImage(
            Image.open("../img/triangle.png").resize((65, 65)))
        circle = PhotoImage(
            Image.open("../img/circle.png").resize((65, 65)))

        return rectangle, triangle, circle  # 로드된 이미지 반환

    def text_value(self, row, col, contents, action, font='Helvetica', size=10,
                   style='normal', anchor="nw"):
        # 그리드 안에 Q 값 표시
        if action == 0:  # 상
            origin_x, origin_y = 7, 42
        elif action == 1:  # 하
            origin_x, origin_y = 85, 42
        elif action == 2:  # 좌
            origin_x, origin_y = 42, 5
        else:  # 우
            origin_x, origin_y = 42, 77

        # 텍스트의 좌표 계산
        x, y = origin_y + (UNIT * col), origin_x + (UNIT * row)
        font = (font, str(size), style)
        text = self.canvas.create_text(x, y, fill="black", text=contents,
                                       font=font, anchor=anchor)
        return self.texts.append(text)

    def print_value_all(self, q_table):
        # 현재 Q 테이블 값을 캔버스에 표시
        for i in self.texts:
            self.canvas.delete(i)
        self.texts.clear()  # 이전 텍스트 지우기
        for i in range(HEIGHT):
            for j in range(WIDTH):
                for action in range(0, 4):
                    state = [i, j]
                    if str(state) in q_table.keys():
                        temp = q_table[str(state)][action]
                        self.text_value(j, i, round(temp, 2), action)

    def coords_to_state(self, coords):
        # 캔버스 좌표를 그리드월드의 상태로 변환
        x = int((coords[0] - 50) / 100)
        y = int((coords[1] - 50) / 100)
        return [x, y]

    def state_to_coords(self, state):
        # 그리드월드 상태를 캔버스 좌표로 변환
        x = int(state[0] * 100 + 50)
        y = int(state[1] * 100 + 50)
        return [x, y]

    def reset(self):
        # 환경을 초기 상태로 리셋
        self.update()
        time.sleep(0.5)  # 딜레이 추가
        x, y = self.canvas.coords(self.rectangle)  # 에이전트의 현재 좌표
        self.canvas.move(self.rectangle, UNIT / 2 - x, UNIT / 2 - y)  # 초기 위치로 이동
        self.render()  # 환경 시각화
        return self.coords_to_state(self.canvas.coords(self.rectangle))  # 초기 상태 반환

    def step(self, action):
        # 주어진 행동에 따라 환경의 상태를 변화시키고 보상을 반환
        state = self.canvas.coords(self.rectangle)  # 현재 에이전트 좌표
        base_action = np.array([0, 0])  # 이동 방향 초기화
        self.render()  # 환경 시각화

        # 행동에 따른 이동 방향 결정
        if action == 0:  # 상
            if state[1] > UNIT:
                base_action[1] -= UNIT
        elif action == 1:  # 하
            if state[1] < (HEIGHT - 1) * UNIT:
                base_action[1] += UNIT
        elif action == 2:  # 좌
            if state[0] > UNIT:
                base_action[0] -= UNIT
        elif action == 3:  # 우
            if state[0] < (WIDTH - 1) * UNIT:
                base_action[0] += UNIT

        # 에이전트 이동
        self.canvas.move(self.rectangle, base_action[0], base_action[1])
        self.canvas.tag_raise(self.rectangle)  # 에이전트를 맨 위로 배치
        next_state = self.canvas.coords(self.rectangle)  # 다음 상태

        # 보상 함수
        if next_state == self.canvas.coords(self.circle):  # 목표 도달
            reward = 100
            done = True
        elif next_state in [self.canvas.coords(self.triangle1),
                            self.canvas.coords(self.triangle2)]:  # 장애물 도달
            reward = -100
            done = True
        else:  # 이동만 한 경우
            reward = 0
            done = False

        next_state = self.coords_to_state(next_state)  # 좌표를 상태로 변환
        return next_state, reward, done  # 다음 상태, 보상, 종료 여부 반환

    def render(self):
        # 환경 시각화 및 딜레이 추가
        time.sleep(0.03)
        self.update()

실행파일

import numpy as np
import random
from environment import Env  # 그리드 월드 환경을 정의하는 사용자 정의 클래스
from collections import defaultdict  # 기본값이 있는 딕셔너리 생성에 사용

class QLearningAgent:
    def __init__(self, actions):
        # Q-Learning 에이전트를 초기화
        # 행동(actions): [0, 1, 2, 3] 순서대로 상, 하, 좌, 우를 의미
        self.actions = actions  # 에이전트가 선택할 수 있는 행동 리스트
        self.learning_rate = 0.01  # 학습률 α: 새 정보 반영 정도
        self.discount_factor = 0.9  # 할인 계수 γ: 미래 보상의 중요도
        self.epsilon = 0.9  # 탐험 확률 ε: 무작위 행동 선택 비율
        # Q 테이블 초기화: 상태별로 [0.0, 0.0, 0.0, 0.0] 초기값을 가지는 딕셔너리
        self.q_table = defaultdict(lambda: [0.0, 0.0, 0.0, 0.0])

    # <s, a, r, s'> 샘플로부터 Q-함수를 업데이트
    def learn(self, state, action, reward, next_state):
        # 현재 상태(state)와 행동(action)에 대한 Q 값
        q_1 = self.q_table[state][action]
        # 벨만 최적 방정식 기반으로 업데이트 대상 Q 값 계산
        # reward + γ * max(Q(s', a')): 현재 보상과 다음 상태에서의 최대 Q 값
        q_2 = reward + self.discount_factor * max(self.q_table[next_state])
        # Q 값 업데이트: 기존 Q 값에 학습률을 곱한 TD 오차를 더함
        self.q_table[state][action] += self.learning_rate * (q_2 - q_1)

    # Q-테이블 기반의 ε-탐욕 정책으로 행동 선택
    def get_action(self, state):
        if np.random.rand() < self.epsilon:
            # 탐험(Exploration): 무작위 행동 선택
            action = np.random.choice(self.actions)
        else:
            # 활용(Exploitation): Q-테이블에서 가장 높은 값을 가진 행동 선택
            state_action = self.q_table[state]
            action = self.arg_max(state_action)
        return action

    @staticmethod
    def arg_max(state_action):
        # Q 값이 최대인 행동을 반환
        max_index_list = []  # 최대 Q 값을 가진 행동들의 인덱스 리스트
        max_value = state_action[0]  # 첫 번째 값을 초기 최대값으로 설정
        for index, value in enumerate(state_action):
            if value > max_value:
                # 새로운 최대값 발견 시 리스트 초기화 후 추가
                max_index_list.clear()
                max_value = value
                max_index_list.append(index)
            elif value == max_value:
                # 최대값과 같은 값을 가진 행동 추가
                max_index_list.append(index)
        return random.choice(max_index_list)  # 최대값 행동 중 무작위로 선택

if __name__ == "__main__":
    env = Env()  # 사용자 정의 환경 초기화
    agent = QLearningAgent(actions=list(range(env.n_actions)))  # 에이전트 초기화

    for episode in range(1000):  # 1000개의 에피소드 동안 학습 반복
        state = env.reset()  # 환경 초기화 및 초기 상태 반환

        while True:  # 한 에피소드 동안 반복
            env.render()  # 환경 시각화 (현재 상태 출력)

            # 현재 상태(state)에 따른 행동(action) 선택
            action = agent.get_action(str(state))
            # 행동 수행 후 다음 상태(next_state), 보상(reward), 종료 여부(done) 반환
            next_state, reward, done = env.step(action)

            # Q-함수 업데이트: <s, a, r, s'> 샘플로 학습
            agent.learn(str(state), action, reward, str(next_state))
            state = next_state  # 상태 업데이트

            # 모든 상태-행동에 대한 Q 값을 화면에 표시
            env.print_value_all(agent.q_table)

            if done:  # 에피소드 종료 조건
                break

• 강화학습의 핵심 목표: 환경과의 상호작용을 통해 기대되는 누적 보상(expected cumulative reward)을 최대화하는 정책(Policy)을 학습하는 것.
• 이는 에이전트가 어떤 상태에서 어떤 행동을 선택해야 할지를 학습하여 장기적으로 최적의 결과를 얻는 것을 의미합니다.

강화학습은 크게 가치 기반 학습과 정책 기반 학습으로 나뉩니다.

1. 가치 기반 학습 (Value-Based Learning)

   • 상태(state, state-action)의 가치 함수를 학습하고 이를 바탕으로 행동을 선택.
   • 대표적인 알고리즘: Q-Learning, SARSA.
   • Q-값(Q-Value): 특정 상태 $s$에서 행동 $a$를 취했을 때 기대되는 총 보상 $Q(s, a)$를 학습합니다.
   • 최적 정책은 다음과 같이 정의됩니다: $\pi^*$(s) = $argmax_a Q(s, a)$

2. 정책 기반 학습 (Policy-Based Learning)

   • 정책 함수 $\pi^*(a|s)$를 직접 학습합니다.
   • 대표적인 알고리즘: Actor-Critic.
   • 연속적인 행동 공간에서도 적용 가능하며, 직접 정책을 최적화합니다.

3. 가치 함수(Value Function)와 정책 함수(Policy Function)

• 가치 함수(Value Function): 상태나 상태-행동 쌍의 "가치"를 나타냅니다.
  • 상태 가치 함수 $V(s)$: 특정 상태 $(s$)의 가치. 지금부터 기대되는 return
  • 행동 가치 함수 $Q(s, a)$: 특정 상태 $(s$)에서 행동 $(a$)를 취했을 때의 가치. 지금 행동으로부터 기대되는 Return
• 정책 함수(Policy Function): 상태 $(s$)에서 행동 $(a$)를 선택할 확률을 나타냅니다.

4. 탐험과 활용 문제 (Exploration vs Exploitation)

• 탐험(Exploration): 새로운 정보를 탐색하기 위해 무작위 행동을 선택.
• 활용(Exploitation): 현재 학습된 최적 행동을 선택하여 보상을 극대화.
• 균형 유지가 중요하며, $epsilon$-탐욕적 정책($epsilon$-greedy)을 사용해 해결합니다.
• $epsilon$-탐욕적 정책: 초기에는 탐험을 많이하고 점차 줄여나가는 정책

정책 이터레이션

• 정책 이터레이션(Policy Iteration)은 가치 기반 학습(Value-Based Learning)에 속함

• 정책 이터레이션은 주어진 정책 하에서 벨만 기대 방정식을 사용해 가치를 평가하고 개선

• 정책 이터레이션은 초기 정책으로 시작해서 점진적으로 개선하여 최적 정책에 도달하는 알고리즘

• 정책 이터레이션은 정책 평가와 정책 개선 단계를 번갈아 수행하면서 최적의 정책을 찾음

• 정책 평가(Policy Evaluation):

  • 현재 정책 하에 각 상태의 가치를 계산. 이 과정에서, 벨만 기대 방정식을 사용하여 모든 상태에 대해 가치 함수를 반복적으로 계산하며, 이는 현재 정책을 따랐을 때 각 상태에서 기대할 수 있는 장기적인 보상의 총합을 의미함

• 정책 개선(Policy Improvement):

  • 계산된 가치 함수 $V^\pi(s)$)를 바탕으로 정책을 업데이트. 정책이 더 이상 개선되지 않을 때(수렴할 때)까지 두 단계를 반복 상태 가치 함수를 사용하여 최적의 정책을 도출
  

• Rule : 세모(-1)를 피해 동그라미(1)에 최단 경로로 도달하여 보상을 획득하는 것이 목적임
• 정책 평가(Evaluate) : 현재 정책에 따라 각 상태의 가치를 계산. 즉, 상태에서 가능한 모든 행동에 대한 기대 보상을 계산하고, 그 값을 바탕으로 상태의 가치를 업데이트
• 정책 개선(Improve) : 각 상태에서 가능한 행동 중, 가장 큰 보상(즉, 더 높은 상태 가치를 제공하는 행동)을 취할 확률이 더 높도록 정책 개선 Move : 현재까지의 정책을 기반으로 에이전트 이동 시작

알고리즘

1. 초기화:

   • 초기 정책 $(\pi_0$)를 무작위로 설정.

2. 반복:

   • 정책 평가: 현재 정책 $\pi_k$에 대한 가치 함수 $(V^{\pi_k}(s)$) 계산.

     $$ ^\pi(s) = \sum_{a} \pi(a|s) \sum_{s'} P(s'|s, a) \big[ R(s, a, s') + \gamma V^\pi(s') \big] $$

   • 정책 개선: 가치 함수 $(V^{\pi_k}(s)$)를 사용해 새로운 정책 $(\pi_{k+1}$) 도출.

     $$ \pi_{k+1}(s) = \arg\max_a \sum_{s'} P(s'|s, a) \big[ R(s, a, s') + \gamma V^{\pi_k}(s') \big] $$

3. 정책이 수렴할 때 종료.

특징

• 장점: 정책과 가치 함수를 동시에 업데이트하기 때문에 수렴 속도가 빠름.
• 단점: 정책 평가 단계가 반복적으로 수행되므로 계산 비용이 클 수 있음.

가치 이터레이션

• 가치 이터레이션(Value Iteration)은 가치 기반 학습(Value-Based Learning)에 속함

• 가치 이터레이션은 각 반복에서 직접적으로 최적의 가치 함수를 추정하고, 이를 바탕으로 최적의 정책을 결정함.

• 이 방법은 정책 평가와 정책 개선 단계를 하나로 합쳐 더 효율적으로 계산할 수 있게 해줌.

• 가치 함수 업데이트:

  • 모든 상태에 대해 가능한 모든 행동의 결과를 고려하여, 각 상태의 가치 함수를 업데이트함
  • 벨만 최적 방정식을 사용하여, 각 상태에서 가능한 행동 중에서 최대의 기대 가치를 제공하는 행동을 통해 가치 함수를 업데이트함.
  • 이렇게 계산된 가치 함수를 기반으로, 각 상태에서 가능한 행동들 중에서 가장 - 높은 가치를 제공하는 행동을 선택하여 최적의 정책을 결정함.

• 가치 이터레이션은 일반적으로 정책 이터레이션보다 더 빠르게 수렴할 수 있으며, 계산 과정이 좀 더 단순함

  

알고리즘

1. 초기화:

   • $V(s)$를 임의의 값으로 초기화 (예: $V(s) = 0$).

2. 반복:

   • 벨만 최적 방정식을 사용해 (V(s))를 업데이트:

     $$ V(s) \leftarrow \max_a \sum_{s'} P(s'|s, a) \big[ R(s, a, s') + \gamma V(s') \big] $$

   • $V(s)$가 수렴할 때까지 반복.

3. 최적 가치 함수 $V^*(s)$를 바탕으로 최적 정책 계산:

$$ \pi^(s) = \arg\max_a \sum_{s'} P(s'|s, a) \big[ R(s, a, s') + \gamma V^(s') \big] $$

특징

• 장점: 정책 평가와 정책 개선 단계를 한 번에 수행하므로 계산이 간단하고 직관적.
• 단점: 더 많은 반복이 필요할 수 있음.

value_iteration.py 파일 실행

• Rule : 세모(-1)를 피해 동그라미(1)에 최단 경로로 도달하여 보상을 획득하는 것이 목적임
• 계산(Calculate) : 각 상태에 대해 최적의 행동을 결정하기 위한 가치를 계산하고 업데이트
• Print Policy : 현재 추정된 최적의 정책을 시각적으로 표시
• Move : 현재까지의 정책을 기반으로 에이전트 이동 시작
• Clear : 최초 실행 상태로 초기화

위 내용에 대한 실습 코드는 https://github.com/rlcode/reinforcement-learning-kr 에서 참조했습니다!

• Streamlit으로 서버를 실행하면 211로 시작하는 IP가 출력되는데, 이를 다른 사람들이 접속할 수 있도록 공유해 보셨나요?
  대부분의 경우, 같은 와이파이에 연결된 사용자들만 접속이 가능했을 겁니다.
• 왜 같은 와이파이 사용자만 접속할 수 있었는지 이유와 다른 와이파이 주소를 사용하는 사람도 접속할 수 있도록 관련 네트워크 지식을 배워 봅시다.

1. IP 주소의 종류

IP 주소는 공인 IP와 사설 IP로 나뉩니다:

공인 IP

• 인터넷 서비스 제공업체(ISP)로부터 할당받는 고유한 IP 주소입니다.
• 전 세계 어디서나 접근할 수 있는 인터넷 주소입니다.
• 예: 125.x.x.x, 211.x.x.x

사설 IP

• 로컬 네트워크(같은 와이파이 또는 공유기)에 속한 기기들끼리 사용할 수 있는 IP입니다.
• 외부 인터넷에서는 접근할 수 없습니다.
• 예: 192.168.x.x, 10.x.x.x, 172.16.x.x ~ 172.31.x.x

2. 211로 시작하는 IP는 왜 같은 네트워크에서만 접속 가능한가?

1. 공유기와 NAT (Network Address Translation)

• 보통 집이나 회사 네트워크의 공유기는 외부와 연결된 공인 IP 하나를 가지고 있습니다.
• 내부 네트워크에 연결된 모든 장치는 공유기를 통해 사설 IP를 할당받습니다.
• 211로 시작하는 IP 주소도 공유기에서 할당된 로컬 IP일 수 있으며, 이 경우 같은 네트워크 내에서만 접근이 가능합니다.

2. 방화벽 설정과 네트워크 라우팅

• 로컬 네트워크에서 서버를 실행하면 방화벽이나 라우팅 설정 때문에 같은 네트워크에 속한 장치들만 접근할 수 있습니다.
• 외부에서 접속하려면 해당 IP가 공인 IP이어야 하고, 포트 포워딩 및 네트워크 설정이 필요합니다.

3. 외부에서 접속하려면 어떻게 해야 하나?

외부에서 Streamlit 서버에 접속하려면 다음 단계를 수행해야 합니다:

1. 공인 IP 확인

• 공유기나 서버에 할당된 공인 IP 주소를 확인합니다.
• https://whatismyip.com 같은 사이트에서 공인 IP를 확인할 수 있습니다.

2. 포트 포워딩 설정

• 공유기 설정에 들어가 포트 포워딩을 설정합니다.
• Streamlit 서버의 로컬 IP와 포트 번호를 외부 공인 IP와 연결합니다.
  예시: 공인IP:8501 → 로컬IP:8501

3. 방화벽 해제

• 서버의 방화벽이 외부 접근을 차단하지 않도록 허용해야 합니다.

• Linux (UFW 방화벽 설정 예시):

   sudo ufw allow 8501
   sudo ufw reload

• window:

  • 제어판 → 방화벽 → 인바운드 규칙 추가 → 포트 허용 설정

4. 도메인 설정 (옵션)

• 공인 IP 대신 DNS 도메인을 설정하면 접근이 더 쉬워집니다.
• 예: http://mydomain.com

5. 결론

• Streamlit 서버가 같은 와이파이 사용자에게만 접근 가능한 이유는 사설 IP와 공유기의 NAT 때문입니다.

• 외부에서도 접속이 가능하도록 하려면:

  • 공인 IP 확인
  • 포트 포워딩 설정
  • 방화벽 허용

• 이 과정을 통해 인터넷 어디서든 Streamlit 서버에 접속할 수 있습니다.

Streamlit 이란?

• Streamlit은 데이터 애플리케이션을 쉽게 만들 수 있도록 도와주는 파이썬 기반의 오픈 소스 프레임워크입니다.

• 특히 데이터 분석, 모델 시각화, 인터랙티브 대시보드를 빠르고 쉽게 구축할 수 있도록 만들어졌습니다.

• Streamlit을 사용하면 복잡한 웹 개발 지식 없이도 직관적인 인터페이스를 갖춘 대화형 웹 애플리케이션을 빠르게 만들 수 있습니다.

  

Streamlit의 주요 특징

1. 간단한 코드로 인터랙티브 앱 개발:

   • Streamlit은 파이썬 코드만으로 웹 애플리케이션을 만들 수 있습니다.
   • HTML, CSS, JavaScript와 같은 웹 개발 언어 없이, 파이썬으로 데이터 시각화, 입력 위젯, 상호작용 기능 등을 쉽게 추가할 수 있습니다.
   

2. 빠른 개발 속도:

   • Streamlit은 개발 속도가 매우 빠릅니다.
   • 코드의 몇 줄만으로 완성도 높은 데이터 애플리케이션을 만들 수 있고, 변경사항이 발생하면 즉시 확인할 수 있습니다. 이는 빠르게 프로토타입을 제작하고, 피드백을 반영하며 반복적으로 개선하기에 이상적입니다.

3. 직관적인 UI 구성:

   • Streamlit은 버튼, 슬라이더, 파일 업로드와 같은 위젯을 통해 사용자가 데이터를 조작할 수 있게 합니다.
   • 사용자는 이러한 위젯을 통해 간단하게 입력을 제공하고, 모델의 결과를 시각적으로 확인할 수 있습니다.

4. 서버 측에서 데이터 처리:

   • Streamlit 앱은 서버에서 실행됩니다.
   • 사용자가 입력을 제공하면 해당 입력은 서버 측에서 처리되어 결과를 렌더링하고, 화면에 즉시 보여주는 방식입니다.
   • 따라서 복잡한 연산이나 모델 추론도 쉽게 구현 가능합니다.

Streamlit 으로 만들어진 웹 페이지 예시

streamlit 활용 사례 및 코드 : https://streamlit.io/gallery

streamlit 설치 및 실행 방법 (Python 3.8 이상, VSCODE 환경 실행 권장)

1. Streamlit 설치: VSCode의 터미널에서 다음 명령어를 실행하여 Streamlit을 설치합니다.

    pip install streamlit

   
   

2. 파이썬 파일 생성: VSCode에서 새 파일을 만들고 확장자를 .py로 저장합니다 (예: app.py).

3. 코드 작성: 생성한 파일에 Streamlit 코드를 작성합니다.

    import streamlit as st

    def main():
        st.title("내 첫 Streamlit 앱")

        st.header("환영합니다!")
        st.write("이것은 Streamlit으로 만든 간단한 웹사이트입니다.")

        name = st.text_input("당신의 이름을 입력하세요")
        if name:
            st.write(f"안녕하세요, {name}님!")

        if st.button("클릭해보세요"):
            st.balloons()

    if __name__ == "__main__":
        main()

이 코드는 다음과 같은 기능을 포함하고 있습니다:

1. 제목과 헤더를 표시합니다.
2. 사용자에게 이름을 입력받고, 입력 시 인사를 출력합니다.
3. 버튼을 클릭하면 풍선 애니메이션이 나타납니다.
4. 이 코드를 실행하려면, VSCode 터미널에서 다음 명령어를 입력하세요:

4. Streamlit 실행: VSCode의 터미널에서 다음 명령어를 실행하여 Streamlit 앱을 실행합니다.

   streamlit run app.py

5. 실행하면 기본 웹 브라우저에 새 탭이 열리고 Streamlit 앱이 표시됩니다. 이제 간단한 Streamlit 웹사이트가 완성되었습니다!

1. 가치 기반 학습 (Value-Based Learning)

• 상태(state)의 가치를 학습하여 최적의 정책을 유도하는 방식입니다.
• 대표적인 알고리즘: Q-Learning, SARSA.
• Q-값(Q-Value): 특정 상태 $s$에서 행동 $a$를 취했을 때 기대되는 총 보상 $Q(s, a)$를 학습합니다.
• 최적 정책은 다음과 같이 정의됩니다: $\pi^*$(s) = $\argmax_a Q(s, a)$

2. 정책 기반 학습 (Policy-Based Learning)

• 정책 함수 $\pi^*(a|s)$를 직접 학습합니다.
• 대표적인 알고리즘: REINFORCE, Actor-Critic.
• 연속적인 행동 공간에서도 적용 가능하며, 직접 정책을 최적화합니다.

3. 가치 함수(Value Function)와 정책 함수(Policy Function)

• 가치 함수(Value Function): 상태나 상태-행동 쌍의 "가치"를 나타냅니다.
  • 상태 가치 함수 $V(s)$: 특정 상태 $(s$)의 가치.
  • 행동 가치 함수 $Q(s, a)$: 특정 상태 $(s$)에서 행동 $(a$)를 취했을 때의 가치.
• 정책 함수(Policy Function): 상태 $(s$)에서 행동 $(a$)를 선택할 확률을 나타냅니다.

4. 탐험과 활용 문제 (Exploration vs Exploitation)

• 탐험(Exploration): 새로운 정보를 탐색하기 위해 무작위 행동을 선택.
• 활용(Exploitation): 현재 학습된 최적 행동을 선택하여 보상을 극대화.
• 균형 유지가 중요하며, $epsilon-탐욕적 정책($($epsilon$)-greedy)이나 Boltzmann 탐색을 사용해 해결합니다.

정책 이터레이션

• 정책 이터레이션은 주어진 정책 하에서 벨만 기대 방정식을 사용해 가치를 평가하고 개선

• 정책 이터레이션은 정책 평가와 정책 개선 단계를 번갈아 수행하면서 최적의 정책을 찾음

• 정책 평가(Policy Evaluation):

  • 현재 정책 하에 각 상태의 가치를 계산. 이 과정에서, 벨만 기대 방정식을 사용하여 모든 상태에 대해 가치 함수를 반복적으로 계산하며, 이는 현재 정책을 따랐을 때 각 상태에서 기대할 수 있는 장기적인 보상의 총합을 의미함

• 정책 개선(Policy Improvement):

  • 평가된 가치 함수를 바탕으로 각 상태에서 최적의 행동을 선택하는 새로운 정책을 만듦.
  • 이 단계에서는 각 상태에 대해 가능한 모든 행동을 고려하고, 가장 높은 기대 리턴을 제공하는 행동을 선택하여 정책을 개선합니다. 정책이 더 이상 개선되지 않을 때(수렴할 때)까지 두 단계를 반복 상태 가치 함수를 사용하여 최적의 정책을 도출
  

• Rule : 세모(-1)를 피해 동그라미(1)에 최단 경로로 도달하여 보상을 획득하는 것이 목적임
• 정책 평가(Evaluate) : 현재 정책에 따라 각 상태의 가치를 계산. 즉, 상태에서 가능한 모든 행동에 대한 기대 보상을 계산하고, 그 값을 바탕으로 상태의 가치를 업데이트
• 정책 개선(Improve) : 각 상태에서 가능한 행동 중, 가장 큰 보상(즉, 더 높은 상태 가치를 제공하는 행동)을 취할 확률이 더 높도록 정책 개선 Move : 현재까지의 정책을 기반으로 에이전트 이동 시작

실행 코드는 https://github.com/rlcode/reinforcement-learning-kr 를 참조해주세요.

가치 이터레이션

• 가치 이터레이션은 각 반복에서 직접적으로 최적의 가치 함수를 추정하고, 이를 바탕으로 최적의 정책을 결정함.

• 이 방법은 정책 평가와 정책 개선 단계를 하나로 합쳐 더 효율적으로 계산할 수 있게 해줌.

• 가치 함수 업데이트:

• 모든 상태에 대해 가능한 모든 행동의 결과를 고려하여, 각 상태의 가치 함수를 업데이트함

• 벨만 최적 방정식을 사용하여, 각 상태에서 가능한 행동 중에서 최대의 기대 가치를 제공하는 행동을 통해 가치 함수를 업데이트함.

• 이렇게 계산된 가치 함수를 기반으로, 각 상태에서 가능한 행동들 중에서 가장 - 높은 가치를 제공하는 행동을 선택하여 최적의 정책을 결정함.

• 가치 이터레이션은 일반적으로 정책 이터레이션보다 더 빠르게 수렴할 수 있으며, 계산 과정이 좀 더 단순함

  

value_iteration.py 파일 실행

• Rule : 세모(-1)를 피해 동그라미(1)에 최단 경로로 도달하여 보상을 획득하는 것이 목적임
• 계산(Calculate) : 각 상태에 대해 최적의 행동을 결정하기 위한 가치를 계산하고 업데이트
• Print Policy : 현재 추정된 최적의 정책을 시각적으로 표시
• Move : 현재까지의 정책을 기반으로 에이전트 이동 시작
• Clear : 최초 실행 상태로 초기화

1. 강화학습의 주요 구성 요소

강화학습은 에이전트가 환경과 상호작용하며 최적의 행동을 학습하는 방식입니다. 이 과정에서 중요한 구성 요소들이 있습니다: 에이전트, 환경, 상태, 행동, 보상입니다.

1.1 에이전트 (Agent)

에이전트는 강화학습의 주체로, 환경과 상호작용하며 행동을 취하고 보상을 받습니다. 에이전트는 주어진 목표를 달성하기 위해 정책(policy)을 학습하고, 이를 통해 최적의 행동을 선택합니다.

• 에이전트의 역할: 주어진 환경에서의 최적의 행동을 학습하는 주체
• 에이전트의 목표: 보상을 최대화하는 행동을 찾아내는 것

1.2 환경 (Environment)

환경은 에이전트가 상호작용하는 외부 세계입니다. 에이전트의 행동에 반응하여 상태를 변화시키고, 보상을 제공합니다. 환경은 에이전트가 받는 피드백의 출처이며, 에이전트는 이 환경에 의해 행동 결과를 인식합니다.

• 환경의 역할: 에이전트의 행동에 따라 상태를 변화시키고 보상을 제공
• 환경의 목표: 에이전트가 최적의 행동을 학습하도록 돕는 것

1.3 상태 (State)

상태는 환경의 특정 순간을 나타내며, 에이전트가 어떤 행동을 취할지 결정하는 중요한 정보입니다. 환경은 여러 개의 상태로 구성되며, 에이전트는 현재 상태를 기반으로 행동을 선택합니다.

• 상태의 정의: 환경의 특정 시점에서의 정보나 조건
• 상태의 예: 체스에서의 보드 상태, 로봇의 위치와 속도

1.4 행동 (Action)

행동은 에이전트가 선택하는 결정으로, 환경에 영향을 미칩니다. 에이전트는 다양한 가능한 행동 중 하나를 선택하고, 그 행동이 결과적으로 상태를 변화시키고 보상을 초래합니다.

• 행동의 정의: 에이전트가 선택할 수 있는 행동들
• 행동의 예: 체스에서의 기물 이동, 로봇의 회전

1.5 보상 (Reward)

보상은 에이전트가 행동을 통해 얻는 피드백입니다. 에이전트는 보상을 최대화하려는 목표를 가지고 학습합니다. 보상은 긍정적일 수도, 부정적일 수도 있으며, 장기적으로 보상을 극대화하는 행동을 학습하는 것이 목표입니다.

• 보상의 정의: 에이전트가 행동을 통해 받는 피드백
• 보상의 예: 체스에서 상대의 기물을 잡았을 때 얻는 점수, 로봇이 목표 지점에 도달했을 때 받는 보상

2. Markov Decision Process (MDP)

Markov Decision Process(MDP)는 강화학습 문제를 모델링하는 수학적 틀입니다. MDP는 에이전트가 환경과 상호작용하며 최적의 정책을 학습하는 과정을 정의합니다. MDP는 네 가지 주요 구성 요소로 이루어져 있습니다:

• 상태(State, S): 환경의 특정 시점에서의 상태
• 행동(Action, A): 에이전트가 선택할 수 있는 행동
• 전이 확률(Transition Probability, P): 에이전트가 특정 상태에서 행동을 선택했을 때, 다음 상태로 전이될 확률
• 보상 함수(Reward Function, R): 에이전트가 특정 상태에서 행동을 취할 때 받는 보상

2.1 Markov Property

MDP는 Markov Property를 따릅니다. 이는 "현재 상태는 이전 상태들과 상관없이 다음 상태를 결정하는 데 충분하다"는 성질입니다. 즉, 에이전트가 현재 상태에서 어떤 행동을 선택하면, 그 결과로 다음 상태와 보상이 결정됩니다. 과거의 상태나 행동은 현재 상태와 보상에 영향을 미치지 않습니다.

2.2 MDP의 수학적 정의

MDP는 5개의 주요 요소로 정의됩니다:

1. S: 상태 공간 (가능한 모든 상태들의 집합)
2. A: 행동 공간 (가능한 모든 행동들의 집합)
3. P(s'|s, a): 전이 확률 함수 (현재 상태 s에서 행동 a를 취했을 때, 상태 s'로 전이될 확률)
4. R(s, a): 보상 함수 (현재 상태 s에서 행동 a를 취했을 때 얻는 보상)
5. γ (Gamma): 할인 인자 (미래의 보상에 대한 현재 가치 평가)

2.3 최적 정책(Optimal Policy)

MDP에서 최적의 정책은 에이전트가 각 상태에서 어떤 행동을 선택해야 하는지를 결정합니다. 이를 통해 에이전트는 장기적으로 보상을 최대화할 수 있습니다. 최적 정책을 찾는 과정은 벨만 방정식을 통해 해결됩니다.

2.4 Bellman 방정식

• 벨만 방정식은 상태에서 최적 행동을 선택하는 수학적 방법을 제공합니다. 이 방정식은 각 상태에서 최적의 보상 값을 계산하는 데 사용됩니다. 최적 정책을 찾는 것은 이 방정식을 풀어 최적의 값을 찾아내는 과정입니다.

  2.4.1 벨만 방정식의 기본 형태

  벨만 방정식은 강화학습에서 가치 함수를 계산하고, 최적의 정책(Optimal Policy)을 찾는 데 중요한 역할을 합니다. 이 방정식은 벨만 기대방정식 (Bellman Expectation Equation)과 벨만 최적방정식 (Bellman Optimality Equation) 두 가지로 나뉩니다.

  2.4.2 벨만 기대방정식 (Bellman Expectation Equation)

  벨만 기대방정식은 주어진 정책$\pi$에 대해 각 상태에서의 가치 함수를 계산하는 식입니다. 특정 정책$\pi$에 대해 상태 (s)의 가치 $V^\pi$는 다음과 같이 정의됩니다:

  $$ V^\pi(s) = \mathbb{E}_{\pi} \left[ R(s, a) + \gamma V^\pi(s') \right] $$

  여기서:

  • $V^\pi(s)$: 정책 $\pi$에 따른 상태 (s)의 가치 함수
  • $R(s, a)$: 상태 $s$에서 행동 $a$를 취했을 때 얻는 보상
  • $\gamma$: 할인 인자 (0과 1 사이의 값)
  • $s'$: 다음 상태
  • $\mathbb{E}_{\pi}$: 정책 $\pi$에 따른 기대값

  이 방정식은 상태 $(s$)에서 특정 정책 $\pi$를 따를 때, 상태 $(s$)의 가치가 현재 보상과 미래 상태의 기대 가치의 합으로 구성된다는 것을 나타냅니다.

  2.4.3 벨만 최적방정식 (Bellman Optimality Equation)

  벨만 최적방정식은 최적 정책을 구하는 데 사용되는 방정식입니다. 상태 (s)에서의 최적 가치 함수 $(V^*(s)$)는 다음과 같이 정의됩니다:

  $$ V^(s) = \max_a \left[ R(s, a) + \gamma \sum_{s'} P(s'|s, a) V^(s') \right] $$

  여기서:

  • $V^*(s)$: 상태 $s$에서의 최적 가치 함수
  • $R(s, a)$: 상태 $s$에서 행동 $a$를 취했을 때 얻는 보상
  • $\gamma$: 할인 인자(감가율)
  • $P(s'|s, a)$: 상태 $s$에서 행동 $a$를 취했을 때, 상태 $s'$로 전이될 확률

  이 방정식은 상태 (s)에서 가능한 모든 행동 중 가장 높은 보상을 제공하는 행동을 선택할 때의 가치를 계산합니다. 즉, 최적 가치 함수는 현재 보상과 미래 상태의 가치를 결합한 값 중 최댓값을 취하게 됩니다.

  2.4.4 최적 정책 (Optimal Policy)

  최적 정책 $(\pi^(s)$)는 주어진 상태 (s)에서 최적의 행동 $(a^$)를 선택하는 정책으로, 벨만 최적방정식을 사용하여 계산할 수 있습니다. 최적 정책은 다음과 같이 정의됩니다:

  $$ \pi^(s) = \arg\max_a \left[ R(s, a) + \gamma \sum_{s'} P(s'|s, a) V^(s') \right] $$

  여기서:

  • $\pi^*(s)$: 상태 (s)에서 최적의 행동을 선택하는 정책
  • $\arg\max$: 가능한 행동 중 가장 큰 값을 주는 행동을 선택

  2.4.5 벨만 방정식의 활용

  • 벨만 방정식은 가치 반복(Value Iteration) 및 정책 반복(Policy Iteration) 알고리즘에서 중요한 역할을 하며, 이를 통해 에이전트는 최적 정책을 학습하고, 주어진 환경에서 장기적인 보상을 최대화할 수 있습니다.

3. 결론

• 에이전트, 환경, 상태, 행동, 보상은 강화학습에서 중요한 구성 요소입니다. 에이전트는 환경과 상호작용하며, 상태를 고려하여 행동을 선택하고 보상을 받습니다.
• Markov Decision Process(MDP)는 강화학습 문제를 모델링하는 수학적 틀로, 상태, 행동, 전이 확률, 보상 함수 등의 요소를 통해 최적의 정책을 학습할 수 있게 합니다.
• Markov Property를 따르는 MDP에서는 현재 상태만이 다음 상태를 결정하는 데 필요한 모든 정보를 제공하므로, 이전 상태는 필요하지 않습니다. 이를 통해 에이전트는 장기적인 보상을 최대화하는 최적의 정책을 학습할 수 있습니다.

1. OpenAI Gym

OpenAI Gym은 강화학습 환경을 제공하는 라이브러리로, 다양한 시뮬레이션 환경을 구축하여 강화학습 실험을 쉽게 할 수 있게 돕습니다. Gym은 강화학습을 위한 여러 환경을 제공하고, 이 환경들에서 에이전트를 훈련시킬 수 있습니다.

주요 특징:

• 다양한 환경(게임, 로봇 시뮬레이션, 제어 문제 등)을 제공합니다.
• Python에서 쉽게 사용할 수 있으며, 강화학습 실험을 위한 표준화된 API를 제공합니다.
• 강화학습 알고리즘을 실험하는 데 필요한 모든 도구를 제공합니다.

환경 예시:

• CartPole: 막대기를 수직으로 세우고 균형을 맞추는 환경
• MountainCar: 두 개의 경사를 오르며 목표를 향해 움직이는 환경
• Atari Games: 다양한 아타리 게임을 강화학습 환경으로 제공

강화학습 실습 환경 설정 및 기본 사용법

강화학습을 실습하려면 먼저 Python 환경을 설정하고 라이브러리를 설치해야 합니다. 여기서는 OpenAI Gym을 사용하여 실습 환경을 설정하는 방법을 소개합니다.

1. Python 환경 설정

1. Python 설치: Python 3.6 이상의 버전이 필요합니다.
2. 필요한 라이브러리 설치:
   • gym: OpenAI Gym을 설치합니다.

!pip install gym

import gym
import matplotlib.pyplot as plt
from IPython.display import display, clear_output

# 환경 생성
env = gym.make('CartPole-v1')

# 환경 초기화
state = env.reset()

# 환경 시뮬레이션 실행
done = False
total_reward = 0

# 시각화를 위한 설정
fig = plt.figure(figsize=(8, 6))
ax = fig.add_subplot(111)

while not done:
    # 랜덤 행동 선택
    action = env.action_space.sample()  # 행동을 랜덤으로 선택

    # 환경에 행동을 적용하고 결과를 받음
    next_state, reward, done, info = env.step(action)

    # 총 보상에 추가
    total_reward += reward

    # 화면에 환경을 렌더링 (matplotlib 사용)
    ax.clear()
    ax.imshow(env.render(mode='rgb_array'))  # 화면을 이미지로 반환
    ax.set_title(f"Total Reward: {total_reward}")
    display(fig)

    # 이전 출력 지우기
    clear_output(wait=True)

# 시뮬레이션 종료 후 총 보상 출력
print(f"총 보상: {total_reward}")

# 환경 종료
env.close()

1. 강화학습(Reinforcement Learning) 정의

강화학습(RL)은 에이전트(agent)가 환경과 상호작용을 통해 보상(reward)을 최대화하는 방법을 학습하는 알고리즘입니다. 에이전트는 여러 상태(state)에서 가능한 행동(action)을 선택하고, 그에 따라 결과와 보상을 받으며 학습합니다. 이 과정에서 에이전트는 최적의 정책(policy)을 학습하려고 합니다.

• 에이전트(Agent): 의사 결정을 내리는 주체
• 환경(Environment): 에이전트가 상호작용하는 대상
• 상태(State): 환경의 현재 상태
• 행동(Action): 에이전트가 선택할 수 있는 가능한 행동
• 보상(Reward): 행동에 대한 피드백, 에이전트가 목표를 얼마나 잘 달성했는지 평가하는 기준

2. 강화학습의 특징

• 시간적 지연: 에이전트는 즉각적인 보상을 받지 않고, 장기적인 보상을 고려하여 학습해야 합니다.
• 탐험과 착오(Exploration vs. Exploitation): 에이전트는 새로운 행동을 시도(탐험)할지, 이미 알고 있는 최적의 행동을 반복(착오)할지 결정해야 합니다.
• 연속적인 학습: 강화학습은 주어진 작업에 대한 완전한 해답을 찾을 때까지 학습을 지속적으로 수행합니다.
• 상태 공간과 행동 공간: 상태와 행동의 공간이 매우 커질 수 있어, 이를 효율적으로 다루는 기술이 필요합니다.

3. 강화학습의 응용 분야

강화학습은 다양한 분야에서 강력한 성능을 발휘합니다. 주요 응용 분야는 다음과 같습니다:

• 게임: 알파고(AlphaGo), 체스, 바둑 등에서의 승패 예측 및 최적의 전략 학습

• 로봇 제어: 로봇의 동작 및 경로 최적화

• 자율주행차: 자율주행차가 주행 경로와 행동을 선택하는 데 강화학습을 사용

• 금융: 주식 투자, 포트폴리오 관리, 알고리즘 트레이딩

• 자연어 처리: 대화형 에이전트, 챗봇의 학습

• 의료: 치료 방법 최적화, 약물 개발

  

강화학습과 지도학습/비지도학습 비교

1. 지도학습(Supervised Learning)과 강화학습의 비교

2. 비지도학습(Unsupervised Learning)과 강화학습의 비교

결론

• 강화학습은 에이전트가 환경과 상호작용하며 보상을 통해 정책을 학습하는 과정으로, 주어진 목표를 달성하는 데 중요한 도구가 됩니다.
• 지도학습과 비지도학습은 주로 데이터가 주어졌을 때 예측을 하는 데 초점을 맞추며, 강화학습은 행동을 통해 경험을 쌓고, 장기적인 보상을 극대화하는 데 중점을 둡니다.