Day73_Ai(9)_Am

FCOnly

import torch.cuda
from torchvision import datasets
from torchvision import transforms
from torch.utils.data import DataLoader
import torch.optim as optim
import torch.nn as nn
import torch
import torch.nn.functional as F


'''
import ssl

ssl._create_default_https_context = ssl._create_unverified_context

인증서가 받아져야 되는데 프로그램에서 발급이 안될 수 있다. 그래서 그냥 써라
'''


cifar10_train = datasets.CIFAR10(root = 'CIFAR10_data/',
                                 train=True,
                                 download=True,
                                 transform=transforms.Compose([
                                     transforms.ToTensor(),
                                     # 확률적인걸 뽑기위해 0~1로
                                     transforms.Normalize((0.5,0.5,0.5),(0.5,0.5,0.5))
                                     # -1에서 1로 바꿔줌. r, g, b 순서
                                 ]))

cifar10_test = datasets.CIFAR10(root = 'CIFAR10_data/',
                                 train=False,
                                 download=True,
                                 transform=transforms.Compose([
                                     transforms.ToTensor(),
                                     # 확률적인걸 뽑기위해 0~1로
                                     transforms.Normalize((0.5,0.5,0.5),(0.5,0.5,0.5))
                                     # -1에서 1로 바꿔줌. r, g, b 순서
                                 ]))

print(cifar10_train.data.shape)
print(cifar10_test.data.shape)
print(cifar10_train.targets)
print(cifar10_train.classes)        #라벨 이름을 볼수 있음

trainloader = DataLoader(cifar10_train, batch_size=128, shuffle=True)
testloader = DataLoader(cifar10_test, batch_size=128, shuffle=True)

dataiter= iter(trainloader)
images, labels = next(dataiter)
print(images.shape)
print(labels)
print(images.shape)


device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
print('using device:', device)

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)
loss_func = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.9, weight_decay=5e-4)

epochs = 20
for epoch in range(epochs):
    model.train()
    running_loss = 0.0
    for idx, (x_train, y_train) in enumerate(trainloader, start=1):
        x_train = x_train.to(device, non_blocking=True)
        y_train = y_train.to(device, non_blocking=True)
        optimizer.zero_grad()
        hypothesis = model(x_train)
        loss =loss_func(hypothesis, y_train)
        loss.backward()
        optimizer.step()

        running_loss += loss.item()

        if idx % 100 == 0:
            print(f'epoch:{epoch+1} / step:{idx} loss:{running_loss/100:.5f}')
            running_loss = 0.0

PATH = './cifar_fc_only.pt'
torch.save(model.state_dict(), PATH)

model.load_state_dict(torch.load(PATH, map_location=device))
model.eval()

correct, total = 0, 0
with torch.no_grad():
    for x_test, y_test in testloader:
        x_test = x_test.to(device, non_blocking=True)
        y_test = y_test.to(device, non_blocking=True)
        outputs = model(x_test)
        preds = torch.argmax(outputs, dim=1)
        total += y_test.size(0)
        correct += (preds ==y_test).sum().item()
    print(f'accuracy: {correct / total * 100:.2f}%')

 

 

CNNEx4_ans

import torch.cuda
from torchvision import datasets
from torchvision import transforms
from torch.utils.data import DataLoader
import torch.optim as optim
import torch.nn as nn
import torch
import torch.nn.functional as F

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

cifar10_train = datasets.CIFAR10(root = 'CIFAR10_data/',
                                 train=True,
                                 download=True,
                                 transform=transforms.Compose([
                                     transforms.ToTensor(),
                                     # 확률적인걸 뽑기위해 0~1로
                                     transforms.Normalize((0.5,0.5,0.5),(0.5,0.5,0.5))
                                     # -1에서 1로 바꿔줌. r, g, b 순서
                                 ]))

cifar10_test = datasets.CIFAR10(root = 'CIFAR10_data/',
                                 train=False,
                                 download=True,
                                 transform=transforms.Compose([
                                     transforms.ToTensor(),
                                     # 확률적인걸 뽑기위해 0~1로
                                     transforms.Normalize((0.5,0.5,0.5),(0.5,0.5,0.5))
                                     # -1에서 1로 바꿔줌. r, g, b 순서
                                 ]))

trainloader = DataLoader(cifar10_train, batch_size=16, shuffle=True)
testloader = DataLoader(cifar10_test, batch_size=16, shuffle=True)


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.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


model = CNNet().to(device)
loss_func = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=0.001, momentum=0.9)

epochs = 20
for epoch in range(epochs):
    model.train()
    running_loss = 0.0
    for idx, (x_train, y_train) in enumerate(trainloader, start=1):
        x_train = x_train.to(device, non_blocking=True)
        y_train = y_train.to(device, non_blocking=True)
        optimizer.zero_grad()
        hypothesis = model(x_train)
        loss =loss_func(hypothesis, y_train)
        loss.backward()
        optimizer.step()

        running_loss += loss.item()

        if idx % 2000 == 0:
            print(f'epoch:{epoch+1} / step:{idx} loss:{running_loss/2000:.5f}')
            running_loss = 0.0

PATH = './cifar_cnn.pt'
torch.save(model.state_dict(), PATH)

model.load_state_dict(torch.load(PATH, map_location=device))
model.eval()

correct, total = 0, 0
with torch.no_grad():
    for x_test, y_test in testloader:
        x_test = x_test.to(device, non_blocking=True)
        y_test = y_test.to(device, non_blocking=True)
        outputs = model(x_test)
        preds = torch.argmax(outputs, dim=1)
        total += y_test.size(0)
        correct += (preds ==y_test).sum().item()
    print(f'accuracy: {correct / total * 100:.2f}%')

 

---