합성곱 신경망 코드 분석(파이토치)

                                    import torch
import torchvision # torchvision for ... what?
import torchvision.transforms as transforms
from google.colab import drive # drive

drive.mount('/content/gdrive') # mount with my gdrive folder

transform = transforms.Compose([ # for what?
    transforms.toTensor(),
    transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
])

# CIFAR-10 학습 데이터 셋 로드
trainset = torchvision.datasets.CIFAR10(
    root='./data',      # 데이터 저장 경로
    train=True,        # 학습용 데이터 셋임을 명시
    download=True,      # 데이터가 없으면 다운로드 하라
    transform=transform # 데이터 변환 적용
)

trainloader = torch.utils.data.DataLoader(
    trainset,
    batch_size=4,   # batch
    shuffle=True,   # 데이터 무작위 적용
    num_workers=2   # 데이터 로딩에 사용할 스레드 수
)

# 테스트용 데이터 set 로드
testset = torchvision.datasets.CIFAR10(
    root = './data',
    train = False, # 테스트용 데이터 셋
    download=True,
    transform=transform
)

# 테스트 데이터 로더 설정
testloader = torch.utils.data.DataLodaer(
    testset,
    batch_size=4,
    shuggle=False,
    num_workers=2
)

classes = ('plane', 'car', 'bird', 'cat', 'deer',
           'dog', 'frog', 'horse', 'ship', 'truck')

# matplotlib, numpy
import matplotlib.pyplot as plt
import numpy as np

def imshow(img):
  img = img / 2 + 0.5 # 정규화 해제
  npimg = img.numpy()   # tensor to numpy array
  plt.imshow(np.transpose(npimg, (1, 2, 0))) # 이미지 차원 변환 후 출력
  plt.show()

dataiter = iter(trainloader)
imgaes, labels = next(dataiter)

imshow(torchvision.utils.make_grid(images))

import torch.nn as nn
import torch.nn.functional as F

class Net(nn.Module):
  def __init__(self):
    super(Net, self).__init__()

    self.conv = nn.Conv2d(3, 6, 5)

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

    self.conv2 = nn.Conv2d(6, 16, 5)

    self.fc1 = nn.Linear(16 * 5 * 5, 120)

    self.fc2= nn.Linear(120, 84)

    self.fc3 = nn.Linear(84, 10)

    def forward(self, x):
      # 첫 번째 합성곱 층 + ReLu 활서오하 + 풀링
      x = self.pool(F.relu(self.conv1(x)))
      # 두 번째 합서곱 층 + ReLu 활성화 + 풀링
      x = self.pool(F.relu(self.conv2(x)))
      # 텐서 1차원으로 변환
      x = x.view(-1, 16 * 5 * 5)
      # 첫 번째 완전 연결 츨 + ReLu
      x = F.relu(self.fc1(x))
      # 두 번째 완전 연결 층 + ReLU
      x = F.relu(self.fc2(x))
      # 세 번째 완전 연결층 (출력)
      x = self.fc3(x)

      return x

net = Net()

# 손실함수와 옵티마이저 설정
import torch.optim as optim

# 교차 엔트로피 손실 함수 사용
criterion = nn.CorssEntropyLoss()
# Adam 옵티마이저 사용, 합습률 0.001
optimizer = optim.Adam(net.paramters(), lr=0.001)

for epoch in range(2):
  running_loss = 0.0
  for i, data in enumerate(trainloader, 0):
    inputs, labels = data

    # 옵티마이저 기울기 초기화
    optimizer.zero_grad()

    # 순전파: 신경망에 입력 데이터를 통과시켜출력 계산
    outputs = net(inputs)
    # 손실 함수 계산
    loss = criterion(outputs, lables)
    # 역전파 : 손실을 기준으로 기울기 계산
    loss.backword()
    #옵티마이저를 사용하여 가중치 업데이트
    optimizer.step()

    running_loss += loss.item()
    if i % 2000 == 1999: # 2000 번째 배치마다 출력
        print(f'[{epoch + 1}, {i +1:5d}]loss: {running_loss / 2000: .3f}')
        running_loss = 0.0 # 손실 초기화

  print('Finished Training') # 학습 완료 메세지

# 테스트 데이터에서 한 배치 가져오기
dataiter = iter(testloader)
images, labels = next(dataiter)

# 테스트용 이미지 출력
imshow(torchivision.utils.make_gird(imgaes))
# 실제 라벨 출력
print('GroundTruth: ', ' '.join(f'{classes[labels[j]]:5}' for j in range(4)))

                                    import torch
import torchvision
import transforms from torch
from google.colab import drive

                                    custom_transform = transforms.Compose([
    transforms.toTensor(),
    transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
])

                                    train_data_set = torchvision.datasets.CIFAR10(
    root = './data',
    train = True,
    download = True,
    trainsform = custom_transform
)

                                    custom_data_loader = torch.utils.data.DataLoader(
    dataset = custom_transform,
    shuffle = True,
    batch_size = 4,
    num_workers = 2
)

                                    import torch.nn as nn
import torch.nn.functional as F

                                    class MyCNNModel(nn.Module):
    def __init__(self):
        super(MYCNNModel, self).__init__()

    def forward(self, x)

                                    1. Convolution layer + Activation func

2. Pooling layer
   : 이미지나 특징 맵의 높이 너비를 줄여 연산량을 감소시킴
   : 과적합 방지 효과 - 노이즈 제거

3. Fully Connected layer(FC)
   : 최종 예측을 출력하는 층

                                    class MyCNNModel(nn.Module):
    def __init__(self):
        # 중략
        self.conv = nn.Conv2d(3, 6, 5)
        self.pool = nn.MaxPool2d(2, 2)
        self.conv2 = nn.Conv2d(6, 15, 5)
        self.fc1 = nn.Linear(16 *5 *5, 120)
        self.fc2 = nn.Linear(120, 84)
        self.fc3 = nn.Linear(84, 10)

                                    def forward(self, x):
    x = self.pool(F.relu(self.conv1(x)))
    x = self.pool(F.relu(self.conv2(x)))
    x = x.view(-1, 16 * 5 * 5)
    x = F.relu(self.fc1(x))
    x = F.relu(self.fc2(x))
    x = self.fc3(x)

    return x

                                    import torch.optim as optim

criterion = nn.CorseEntropyLoss()
optimizer = optim.Adam(customModel.parameters(), lr=0.001) # 학습률 0.001

                                    for epoch in range(2): # epoch 2로 설정 - 전체 데이를 총 두번 학습한다.
    running_loss = 0.0
    for i, data in enumerate(custom_data_loader, 0):
        inputs, labels = data

        optimizer.zero_grad() #손실함수의 기울기를 초기화 - 이전 배치와 독립적이게 계산

        output = net(inputs)  # 실제코드에서는 모듈을 net으로 정의 - forward를 수행하는 것을 의미

        loss = criterion(outputs, labels)
        # criterion은 손실 함수로, 모델 출려과 실제 정답(label)의 차이를 계산
        # loss는 object이다.

        loss.backward() # loss가 나오면 이를 역전파함 - 모델 가중치 편햐 업데이트

        optimizer.step() # 각 파라미터를 업데이트 하는 함수

        running_loss += loss.item()

        if i % 2000 == 1999:  #2000번 배치마다 출력, 손실 초기화
            print(f'[{epoch + 1}, {i +1:5d}]loss: {running_loss / 2000: .3f}')
            running_loss = 0.0 # 손실 초기화

                                    classes = ('plane', 'car', 'bird', 'cat', 'deer',
           'dog', 'frog', 'horse', 'ship', 'truck')

                                    1. 데이터 로드: transloader에서 배치 단위로 입력 이미지와 정답 라벨을 가져옴

2. 기울기 초기화: 이전 배치에서 계산된 기울기를 초기화함

3. 순전파 시행

4. 손실 계산

5. 역전파 시행

6. 파라미터 업데이트

7. 손실 기록

8. 다음 배치로 반복

                                    test_data = torchvision.datasets.CIFAR10(
    root = './data',
    download = true,
    train = False,
    transform = transform
)

test_loader = torch.utils.data.DataLoader(
    test_data,
    batch_size = 4,
    shuffle = False,
    num_workers = 2
)

                                    def imshow(img):
  img = img / 2 + 0.5 # 정규화 해제
  npimg = img.numpy()   # tensor to numpy array
  plt.imshow(np.transpose(npimg, (1, 2, 0))) # 이미지 차원 변환 후 출력
  plt.show()

                                    dataiter = iter(testloader)
images, labels = next(dataiter)

# 테스트용 이미지 출력
imshow(torchivision.utils.make_gird(imgaes))