전이 학습

from pathlib import Path

폴더 = Path('data/cats_dogs_small')
assert 폴더.is_dir(), f'{폴더} 폴더가 없습니다.'

# 하위 폴더 확인
for 하위폴더 in 폴더.iterdir():
    print(하위폴더)

# 파일 획득
files = {}
for split in ['train', 'validation', 'test']:
    files[split] = list((폴더 / split).glob('**/*.jpg'))
    print(f'{split:<10}: {len(files[split]):,} files')

# PIL: Python Imaging Library
import PIL.Image as Image

sample = files['train'][0]
print(sample)
print(sample.name)
print(sample.stem)
# PIL 라이브러리를 사용하여 이미지 열기
with Image.open(sample) as img:
    print(type(img), img.size, img.mode)
    # with 블럭 외부에서 img 객체는 자동으로 닫히므로, 복사본을 만들어서 사용
    sample = img.copy()
    
display(sample)

import PIL.Image as Image

class CatDogDataset:
    def __init__(self, 폴더, transform=None):
        self.폴더 = Path(폴더)
        self.파일들 = list(self.폴더.glob('**/*.jpg'))
        self.labels = {'cat': 0, 'dog': 1}
        self.transform = transform
    
    def __len__(self):
        return len(self.파일들)
    
    def __getitem__(self, 색인):
        파일 = self.파일들[색인]
        target = self.labels['cat' if 'cat' in 파일.stem else 'dog']
        with Image.open(파일) as img:
            sample = img.copy()
        if self.transform:
            sample = self.transform(sample)
        return sample, target

import torchvision.transforms as transforms

%run catdog.py

전처리 = transforms.Compose([
    transforms.Resize((180, 180)),
    transforms.ToTensor()
])

datasets = {}
for 하위폴더 in 폴더.iterdir():
    split = 하위폴더.name
    datasets[split] = CatDogDataset(하위폴더, transform=전처리)
    print(f'{split:<10}: {len(datasets[split]):,} samples')

sample, label = datasets['train'][1000]
print(type(sample))
print(f"label: {'cat' if label == 0 else 'dog'}")
try:
    sample - sample
except Exception as e:
    # 이미지 객체는 연산 불가
    print(e)

display(transforms.ToPILImage()(sample))

import torch

dataloaders = {}
for split in datasets.keys():
    dataloaders[split] = torch.utils.data.DataLoader(
        datasets[split], batch_size=32, shuffle=(split=='train'))
    print(f'{split:<10}: {len(dataloaders[split]):,} batches')

for X_batch, y_batch in dataloaders['train']:
    print(X_batch.shape, y_batch.shape)
    break

from keras import layers

keras.backend.clear_session()
# keras.backend.set_image_data_format('channels_last')

model = keras.Sequential()
model.add(keras.Input(shape=(3, 180, 180))) # channels first 형식
# (C, H, W) -> (H, W, C)로 변환하는 레이어
model.add(layers.Permute((2, 3, 1))) # (B, C, H, W) -> (B, H, W, C)
# 은닉층
for units in [32, 64, 128, 256]:
    model.add(layers.Conv2D(
        units, kernel_size=3, activation='relu'))
    model.add(layers.MaxPooling2D(pool_size=2))

model.add(layers.Conv2D(256, kernel_size=3, activation='relu'))
# 출력층
model.add(layers.Flatten())
model.add(layers.Dense(1, activation='sigmoid')) # 이진 분류 출력

model.summary()

model.compile(
    # 이진 분류 문제이므로, BinaryCrossentropy 손실 함수를 사용
    loss=keras.losses.BinaryCrossentropy(),
    # 학습률 튜닝을 줄이기 위해 자동 학습률 조정 가능한 RMSprop 사용
    optimizer=keras.optimizers.RMSprop(),
    metrics=['accuracy']
)

%run catdog.py
history = model.fit(
    dataloaders['train'],
    validation_data=dataloaders['validation'],
    epochs=30,
    callbacks=[
        keras.callbacks.ModelCheckpoint(
            'catdog.keras', save_best_only=True, monitor='val_loss'),
        # # 조기 종료
        # keras.callbacks.EarlyStopping(
        #     monitor='val_loss', patience=5, restore_best_weights=True)
    ]
)

train_results = pd.DataFrame(history.history)
plt.figure(figsize=(10, 4))
왼쪽 = plt.subplot(1, 2, 1) # 1행 2열의 1번째 위치
train_results.plot(y=['loss', 'val_loss'], ax=왼쪽)
오른쪽 = plt.subplot(1, 2, 2) # 1행 2열의 2번째 위치
train_results.plot(y=['accuracy', 'val_accuracy'], ax=오른쪽)
plt.tight_layout()
plt.show()

train_results.round(2)

# best 모델 로드
model = keras.models.load_model('catdog.keras')
test_results = model.evaluate(dataloaders['test'], return_dict=True)
print(pd.Series(test_results).round(4))

from keras.applications import vgg16

model = vgg16.VGG16(weights='imagenet')
model.summary()

from PIL import Image

# 모찌 이미지 열기
with Image.open('data/mozzi.png') as img:
    img = img.resize((224, 224)).convert('RGB')
    print(type(img), img.size, img.mode)
    sample = img.copy()
display(sample)

x1 = np.array(sample)
x1 = vgg16.preprocess_input(x1) # VGG16 모델에 맞게 전처리
print(type(x1), x1.shape, x1.dtype, x1.min(), x1.max())

outputs = model.predict(np.array([x1]))
print(type(outputs), outputs.shape, outputs.dtype)
예측, 확률 = np.argmax(outputs, axis=1), np.max(outputs, axis=1)
print(f'예측: {예측[0]}, 확률: {확률[0]:.2%}')

pd.DataFrame(vgg16.decode_predictions(outputs, top=3)[0]).round(2)

keras.backend.clear_session()

기반모델 = vgg16.VGG16(weights='imagenet', include_top=False, input_shape=(180, 180, 3))
# 기반모델.summary()

from keras import layers

기반모델.trainable = False
model = keras.Sequential([
    기반모델,
    layers.Flatten(),
    layers.Dropout(0.5),
    layers.Dense(1, activation='sigmoid')
])
# model.summary()
model.compile(
    loss=keras.losses.binary_crossentropy,
    optimizer='rmsprop',
    metrics=['acc']
)

!conda run --no-capture-output --name pytorch python catdog_transfer_vgg16.py

import pandas as pd

results = pd.read_csv('catdog_transfer.csv')
results.tail().round(3)