Day73_Ai(9)_Pm

modelUseTest

import torch
import torch.nn.functional as F
import torchvision.transforms as transforms
from PIL import Image
import torch.nn as nn

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

class CNNet(nn.Module):
    def __init__(self):
        super().__init__()
        self.conv1 = nn.Conv2d(3,32,5)
        self.conv2 = nn.Conv2d(32,64,5)
        self.conv3 = nn.Conv2d(64,128,5)

        self.pool = nn.MaxPool2d(2,2, padding=1)

        self.fc1 = nn.Linear(128*2*2, 256)
        self.fc2 = nn.Linear(256, 128)
        self.fc3 = nn.Linear(128, 64)
        self.fc4 = nn.Linear(64,10)

        self.dropout = nn.Dropout(p=0.5)

    def forward(self, x):
        x = F.relu(self.conv1(x))
        x = self.pool(x)

        x = F.relu(self.conv2(x))
        x = self.pool(x)

        x = F.relu(self.conv3(x))
        x = self.dropout(x)
        x = self.pool(x)

        x = x.view(-1, 128*2*2)
        x = F.relu(self.fc1(x))
        x = self.dropout(x)
        x = F.relu(self.fc2(x))
        x = F.relu(self.fc3(x))
        y = self.fc4(x)
        return y

class FCNet(nn.Module):
    def __init__(self):
        super().__init__()
        self.flatten = nn.Flatten()
        self.fc1 = nn.Linear(3*32*32, 1024)
        self.fc2 = nn.Linear(1024, 512)
        self.fc3 = nn.Linear(512, 256)
        self.fc4 = nn.Linear(256, 128)
        self.fc5 = nn.Linear(128, 10)
        self.dropout = nn.Dropout(0.5)

    def forward(self, x):
        x = self.flatten(x) #(16, 3072)
        x = F.relu(self.fc1(x))
        x = self.dropout(x)
        x = F.relu(self.fc2(x))
        x = self.dropout(x)
        x = F.relu(self.fc3(x))
        x = F.relu(self.fc4(x))
        y = self.fc5(x)
        return y

model = FCNet().to(device)
model.load_state_dict(torch.load('./cifar_fc_only.pt',map_location=device))
model.eval()

model = CNNet().to(device)
model.load_state_dict(torch.load('./cifar_cnn.pt',map_location=device))



classes = ['plane','car','bird','cat','deer',
           'dog','for','horse','ship','truck']

transforms = transforms.Compose([
    transforms.Resize((32,32)),
    transforms.ToTensor(),
    transforms.Normalize((0.5,0.5,0.5),(0.5,0.5,0.5))
])

image = Image.open('./sample2.jpg').convert('RGB')
input_tensor =transforms(image).unsqueeze(dim=0).to(device)
print(input_tensor.size())

with torch.no_grad():
    outputs = model(input_tensor)
    probs = torch.softmax(outputs, dim=1)
    conf, predicted = torch.max(probs, dim=1)

pred_class = classes[predicted.item()]
print(f'예측 결과: {pred_class}')
print(f'선택 확률: {conf.item() * 100:.2f}%\n')

for i , cls_name in enumerate(classes):
    print(f'{cls_name:>10s}: {probs[0][i]%100:2f}%')

 

---

 

VGG19Ex

import matplotlib.pyplot as plt
import torch
import torch.nn as nn
import torch.optim as optim
import torchvision.transforms as transforms
import torchvision.models as models
from torch.utils.data import DataLoader
from torchvision.datasets import ImageFolder

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

#이미지 찍기
def display_images(image_paths, title, max_images=4):
    plt.figure(figsize=(16,4))
    for i, image_path in enumerate(image_paths[:max_images]):
        img = plt.imread(image_path)
        plt.subplot(1, max_images, i+1)
        plt.imshow(img)
        plt.title(title)
        plt.axis('off')
    # plt.show()

categories = ['train santa', 'train normal', 'val santa', 'val normal',
              'test santa', 'test normal']

import glob

for category in categories:
    image_paths = glob.glob(
        f'data/santaImage/{category.lower().replace(" ", "/")}/*'
    )
    display_images(image_paths, category)
    # print(f'{category} 총 이미지 수 : {len(image_paths)}')


transform = transforms.Compose([
    transforms.Resize((224,224)),
    transforms.RandomRotation(degrees=30),       #0~ 30도 무작위로 가져옴
    transforms.ToTensor(),  #0~1로
    transforms.Normalize(mean=[0.485, 0.456, 0.406],std=[0.229, 0.224, 0.225])
])

train_path = 'data/santaImage/train'
val_path = 'data/santaImage/val'

train_dataset = ImageFolder(train_path, transform=transform)
val_dataset = ImageFolder(train_path, transform=transform)
# ImageFolder = 폴더이름으로 라벨로 쓰고 순서대로 idx 지정됨

print(train_dataset)
print(train_dataset.classes)    #label 값 확인할 수 있음

train_loader = DataLoader(train_dataset, batch_size=16, shuffle=True)
val_loader = DataLoader(val_dataset, batch_size=16, shuffle=False)

class VGG19(nn.Module):
    def __init__(self, num_classes=1000):
        super().__init__()
        #super(VGG16, self) 파이썬은 다중상속이 가능하지만 쓰면 안좋/ 누가받았는지
        self.features = nn.Sequential(
            #conv block1
            nn.Conv2d(3,64,kernel_size=3,padding=1),   #컴벌루션
            nn.ReLU(),
            nn.Conv2d(64,64,kernel_size=3,padding=1),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=2, stride=2),

            #conv block2
            nn.Conv2d(64, 128, kernel_size=3, padding=1),
            nn.ReLU(),
            nn.Conv2d(128, 128, kernel_size=3, padding=1),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=2, stride=2),

            # conv block3
            nn.Conv2d(128, 256, kernel_size=3, padding=1),
            nn.ReLU(),
            nn.Conv2d(256, 256, kernel_size=3, padding=1),
            nn.ReLU(),
            nn.Conv2d(256, 256, kernel_size=3, padding=1),
            nn.ReLU(),
            nn.Conv2d(256, 256, kernel_size=3, padding=1),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=2, stride=2),

            # conv block4
            nn.Conv2d(256, 512, kernel_size=3, padding=1),
            nn.ReLU(),
            nn.Conv2d(512, 512, kernel_size=3, padding=1),
            nn.ReLU(),
            nn.Conv2d(512, 512, kernel_size=3, padding=1),
            nn.ReLU(),
            nn.Conv2d(512, 512, kernel_size=3, padding=1),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=2, stride=2),

            # conv block5
            nn.Conv2d(512, 512, kernel_size=3, padding=1),
            nn.ReLU(),
            nn.Conv2d(512, 512, kernel_size=3, padding=1),
            nn.ReLU(),
            nn.Conv2d(512, 512, kernel_size=3, padding=1),
            nn.ReLU(),
            nn.Conv2d(512, 512, kernel_size=3, padding=1),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=2, stride=2),
        )

        self.classifier = nn.Sequential(
            nn.Linear(512*7*7, 4096),
            nn.ReLU(),
            nn.Dropout(),
            nn.Linear(4096, 4096),
            nn.ReLU(),
            nn.Dropout(),
            nn.Linear(4096, num_classes),
        )

    def forward(self, x):
        x = self.features(x)
        x = torch.flatten(x, start_dim=1)  #dim = 1 뒤에 다 플렛, batch 남고 뒤에 다
        y = self.classifier(x)
        return y

model = VGG19(num_classes=1).to(device)
loss_func = nn.BCEWithLogitsLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001, weight_decay=5e-4)

def validate_model(model, loader, loss_fn):
    model.eval()
    total, correct = 0, 0
    val_loss = 0.0
    with torch.no_grad():
        for x_batch, y_batch in loader:
            x_batch = x_batch.to(device)
            y_batch = y_batch.to(device).float().unsqueeze(dim=1)
            output = model(x_batch)
            val_loss += loss_fn(output, y_batch).item()
            pred = (torch.sigmoid(output) > 0.5).long()
            correct += (pred == y_batch.long()).sum().item()
            total += y_batch.size(0)
    return val_loss / len(loader), 100.0 * correct / total

def train_model(model, train_loader, val_loader, loss_fn, num_epochs=20):
    train_losses, val_losses, val_accs = [],[],[]
    for epoch in range(num_epochs):
        model.train()
        running_loss = 0.0
        for x_train, y_train in train_loader:
            x_train = x_train.to(device)
            y_train = y_train.to(device).float().unsqueeze(dim=1)
            optimizer.zero_grad()
            hypothesis = model(x_train)
            loss = loss_fn(hypothesis, y_train)
            loss.backward()
            optimizer.step()
            running_loss += loss.item()
        train_loss = running_loss / len(train_loader)
        val_loss, val_acc = validate_model(model, val_loader, loss_fn)
        train_losses.append(train_loss)
        val_losses.append(val_loss)
        val_accs.append(val_acc)
        print(f'epoch:{epoch+1} | train loss:{train_loss:.4f} val loss:{val_loss:.4f}'+
              f'| val_acc:{val_acc:.2f}%')
    return train_losses, val_losses, val_accs

train_losses,val_losses, val_accs = train_model(model,
                                                train_loader,
                                                val_loader,
                                                loss_func,
                                                num_epochs=20)

---