코딩 공부하는 춘식이

PINN 공부 (1)

김춘식_123 — Fri, 6 Sep 2024 16:19:05 +0900

PINN (Physics - Informed Neural Network)

- 물리 법칙을 신경망에 직접 통합하여 복잡한 물리적 시스템을 모델링하고, 해석하며, 예측하는 딥러닝 기법

그 전에 PINN을 왜 사용해야 하는지 생각해보자.

딥러닝의 문제점은 크게 두가지로 꼽을 수 있다.

1. data-driven

데이터로 학습을 시키기 때문에 과도하게 데이터에 의존한다.

'데이터가 충분하다면, 예측 성능이 domain 지식이 부족해도 좋게 나온다.' 라는 말에는 항상 '데이터가 충분하다면'이라는 가정이 붙는다.

따라서, 데이터가 부족한 문제에서는 사용하기 어렵다.

2. blackbox

아래와 같은 신경망을 사용한 딥러닝을 한다고 가정하자.

예측 성능이 좋아도 왜 좋은지 아무도 알 수 없다.

이것을 blackbox라고 한다. (아래 그림 참조)

그에 따라 오류가 발생하면 디버깅을 하지만 해결하기에 어려움을 겪는다.

이러한 문제점을 크게

1. Interpretability (해석 가능성)

2. Generalizability (일반화 능력)

라고 한다.

자, 그럼 이제 딥러닝의 문제점은 확실히 알았을 것이다!

그럼 대체 PINN으로 이 문제를 어떻게 해결한다는 것일까?

→ physics - informed AI 로 해결 할 것이다.

(data + physics to build a model)

PINN공부를,

https://youtu.be/vFghJ0r39K4?si=pWgs3lqSGo3ZU1ro

잘 모르는 사람도 보기 좋은 것 같다.

여기서 하였다.

이 영상에서는

(ANN - 미분 방정식 - 정규화)

저 부분만 공부를 하기 미리 참고하면 좋을 것 같다.

참고로 데이터는 아예 사용하지 않을 것이다.

이러한 식이 있다면,

PINN에서는 수식에 의존한다는 것을 명심하라 !

처음에는 0이 나오지 않겠지만 점점 오차를 줄여가며 0으로 맞추는 과정을 가지는 것이다.

(물론 완벽하게 0으로 되진 않을 것이다. . . )

PINN의 특징

1. Loss function uning strong form

2. Meshfree approach

3. Deep collocation method

실습

A simple ODE system — DeepXDE 1.12.1.dev6+gd0c5aa2 documentation

간단한 ODE 풀기

초기조건:

참조 솔루션:

deepxde를 사용한 코드

"""Backend supported: tensorflow.compat.v1, tensorflow, pytorch, jax, paddle"""
import deepxde as dde
import numpy as np


def ode_system(x, y):
    """ODE system.
    dy1/dx = y2
    dy2/dx = -y1
    """
    # Most backends
    y1, y2 = y[:, 0:1], y[:, 1:]
    dy1_x = dde.grad.jacobian(y, x, i=0)
    dy2_x = dde.grad.jacobian(y, x, i=1)
    # Backend jax~
    # y_val, y_fn = y
    # y1, y2 = y_val[:, 0:1], y_val[:, 1:]
    # dy1_x, _ = dde.grad.jacobian(y, x, i=0)
    # dy2_x, _ = dde.grad.jaco`bian(y, x, i=1)
    return [dy1_x - y2, dy2_x + y1]


def boundary(_, on_initial):
    return on_initial


def func(x):
    """
    y1 = sin(x)
    y2 = cos(x)
    """
    return np.hstack((np.sin(x), np.cos(x)))


geom = dde.geometry.TimeDomain(0, 10)
ic1 = dde.icbc.IC(geom, lambda x: 0, boundary, component=0)
ic2 = dde.icbc.IC(geom, lambda x: 1, boundary, component=1)
data = dde.data.PDE(geom, ode_system, [ic1, ic2], 35, 2, solution=func, num_test=100)

layer_size = [1] + [50] * 3 + [2]
activation = "tanh"
initializer = "Glorot uniform"
net = dde.nn.FNN(layer_size, activation, initializer)

model = dde.Model(data, net)
model.compile("adam", lr=0.001, metrics=["l2 relative error"])
losshistory, train_state = model.train(iterations=20000)

dde.saveplot(losshistory, train_state, issave=True, isplot=True)

PYTORCH 로 변환

개인적으로 바꿔본거라 코드가 지저분하거나 잘 못된 부분이 있을수도 있습니다.

import torch
import torch.nn as nn
import torch.optim as optim
import numpy as np
import matplotlib.pyplot as plt

class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.hidden1 = nn.Linear(1, 50)
        self.hidden2 = nn.Linear(50, 50)
        self.hidden3 = nn.Linear(50, 50)
        self.output = nn.Linear(50, 2)
        self.activation = torch.tanh

    def forward(self, x):
        x = self.activation(self.hidden1(x))
        x = self.activation(self.hidden2(x))
        x = self.activation(self.hidden3(x))
        return self.output(x)
        
net = Net()
optimizer = optim.Adam(net.parameters(), lr=0.001)

# ODE 정의
def ode_loss(x, y_pred):
    y1, y2 = y_pred[:, 0:1], y_pred[:, 1:2]
    dy1_dx = torch.autograd.grad(y1, x, torch.ones_like(y1), create_graph=True)[0]
    dy2_dx = torch.autograd.grad(y2, x, torch.ones_like(y2), create_graph=True)[0]
    ode1 = dy1_dx - y2
    ode2 = dy2_dx + y1
    return torch.mean(ode1**2 + ode2**2)

def boundary_loss(y_pred_bc, y1_bc, y2_bc):
    y1_pred, y2_pred = y_pred_bc[:, 0:1], y_pred_bc[:, 1:2]
    return torch.mean((y1_pred - y1_bc)**2 + (y2_pred - y2_bc)**2)

# 해
def solution(x): 
    """
    y1 = sin(x)
    y2 = cos(x)
    """
    return np.hstack((np.sin(x), np.cos(x)))

# 경계 조건
x_bc_np = np.zeros((500, 1))
y1_bc_np = np.zeros((500, 1))
y2_bc_np = np.ones((500, 1))

x_bc = torch.tensor(x_bc_np, dtype=torch.float32)
y1_bc = torch.tensor(y1_bc_np, dtype=torch.float32)
y2_bc = torch.tensor(y2_bc_np, dtype=torch.float32)

x_train = torch.rand(500, 1) * 10  # 0과 10 사이의 랜덤 값 생성
x_train.requires_grad_(True)  # 기울기 추적

# 학습
num_epochs = 20000
for i in range(num_epochs):
    optimizer.zero_grad()

    y_pred = net(x_train)
    
    y_pred_bc = net(x_bc)

    loss_ode = ode_loss(x_train, y_pred)
    loss_bc = boundary_loss(y_pred_bc, y1_bc, y2_bc) 
    loss = loss_ode + loss_bc
    
    loss.backward()
    optimizer.step()

    if i % 1000 == 0:
        print(f"Iteration {i}: Loss = {loss.item()}")
        
x_test = torch.rand(300, 1) * 10  # 0과 10 사이의 랜덤 값 생성
y_test = net(x_test).detach().numpy()
y_true = solution(x_test.detach().numpy())

# x_test와 그에 대응하는 y_test, y_true를 정렬
sorted_indices = x_test[:, 0].argsort()  # 첫 번째 차원 기준으로 정렬
x_test_sorted = x_test[sorted_indices].detach().numpy()
y_test_sorted = y_test[sorted_indices]
y_true_sorted = y_true[sorted_indices]

# 시각화
plt.plot(x_test_sorted, y_test_sorted[:, 0], label="y1_pred", linestyle="--")
plt.plot(x_test_sorted, y_test_sorted[:, 1], label="y2_pred", linestyle="--")
plt.plot(x_test_sorted, y_true_sorted[:, 0], label="y1_true")
plt.plot(x_test_sorted, y_true_sorted[:, 1], label="y2_true")

plt.legend()
plt.show()

나쁘지 않다.

파이토치란?

김춘식_123 — Wed, 28 Aug 2024 15:47:54 +0900

파이토치란?

파이토치는 2017년 초에 공개된 딥러닝 프레임워크로 루아 언어로 개발되었던 토치를 페이스북에서 파이썬 버전으로 내놓은 것이다.

파이썬(Python) 기반의 오픈소스 머신러닝 라이브러리로, 주로 딥러닝 연구 및 개발에 사용된다.

사용 대상

파이썬 기반의 과학 연산 패키지로 두 집단을 대상으로 한다.

1. 넘파이를 대체하면서 GPU를 이용한 연산이 필요한 경유

2. 최대한의 유연성과 속도를 제공하는 딥러닝 연구 플랫폼이 필요한 경우

파이토치 특징

GPU에서 텐서 조작 및 동적 신경망 구축이 가능한 프레임워크

GPU: 연산 속도를 빠르게 하는 역할

텐서(Tensor): 파이토치의 데이터 형태, 단일 데이터 형식으로 된 자료들의 다차원 행렬

동적 신경망: 훈련을 반복할 때마다 네트워크 변경이 가능한 신경

- 인공지능에서 데이터는 벡터로 표현된다.

1차원 축(행) = axis 0 = 벡터

2차원 축(행) = axis 1 = 행렬

3차월 축(행) = axis 2 = 텐서

파이토치의 장점

1. 단순함

파이썬 환경과 쉽게 통합

디버깅이 직관적이고 간결

2. 성능(낮은 GPU 활용)

모델 훈련을 위한 CPU사용률이 텐서플로와 비교하여 낮음

학습 및 추론 속도가 빠르게 다루기 쉬움

3. 직관적인 인터페이스

텐서플로처럼 잦은 API 변경이 없어 배우기 쉬움

파이토치 모듈

1. 자동 미분 모듈

- PyTorch는 자동 미분이라는 기법 사용

- 레코더는 수행한 작업을 기록한 다음 거꾸로 재생하여 경사를 계산

- 이 기술은 전방 패스에서 매개 변수의 미분을 계산하여 한 시대에서 시간을 절약하기 위해 신경 네트워크를 구축할 때 특히 강력하다.

2. 최적화 모듈

- torch.optim은 신경 네트워크를 구축하는 데 사용되는 다양한 최적화 알고리즘을 구현하는 모듈

- 일반적으로 사용되는 대부분의 방법은 이미 지원되므로 처음부터 새로 만들 필요가 없다.

3. nn 모듈

- autograd 모듈을 사용하면 계산 그래프를 쉽게 정의하고 구배를 얻을 수 있지만, 원시 자동 그립은 복잡한 신경 네트워크를 정의하기에는 autograd 모듈을 직접 쓰기에는 너무 저수준의 작업이 될 것이다. 여기서 nn모듈이 도움이 된다.

파이토치 아키텍처(구조)

딥러닝 파이토치 교과서: 2.1.2 파이토치의 아키텍처 (thebook.io)

크게 세 개의 계층으로 이루어져있다.

가장 상위 계층은 파이토치 API가 위치해 있으며 그 아래에는 파이토치 엔진이 있다.

파이토치 엔진에서는 다차원 텐서 및 자동 미분을 처리한다.

가장 아래에는 텐서에 대한 연산을 처리한다.

CPU/GPU를 이용하는 텐서의 실질적인 계산을 위한 C, CUDA 등 라이브러리가 위치합니다.

파이토치 API

사용자가 이해하기 쉬운 API를 제공하여 텐서에 대한 처리와 신경망을 구축하고 훈련할 수 있도록 돕는다.

이 계층에서는 사용자 인터페이스를 제공하지만 실제 계산은 수행하지 않는다.

그 대신 C++로 작성된 파이토치 엔진으로 그 작업을 전달하는 역할만 한다.

파이토치 API 계층에서는 사용자의 편의성을 위해 패키지들이 제공

ex) torch, torch.autograd, torch.nn 등

파이토치 엔진

Autograd C++는 가중치, 바이어스를 업데이트하는 과정에서 필요한 미분을 자동으로 계산해 주는 역할을 한다. JIT C++는 계산을 최적화하기 위한 JIT(Just In-Time) 컴파일러이다.

파이토치 엔진 라이브러리는 C++로 감싼(래핑(wrapping)) 다음 Python API 형태로 제공되기 때문에 사용자들이 손쉽게 모델을 구축하고 텐서를 사용할 수 있습니다.

딥러닝 파이토치 교과서: 2.1.2 파이토치의 아키텍처 - 2 (thebook.io) 여

연산처리

C 또는 CUDA 패키지는 상위의 API에서 할당된 거의 모든 계산을 수행한다.

여기에서 제공되는 패키지는 CPU와 GPU(TH(토치), THC(토치 CUDA))를 이용하여 효율적인 데이터 구조, 다차원 텐서에 대한 연산을 처리한다.

텐서플로우와 차이점

파이토치가 텐서플로우를 이겼다, 2020 AI현황보고서 8대 전망 < 기술 < 기사본문 - AI타임스 (aitimes.com)

파이토치 패키지

PyTorch - 위키백과, 우리 모두의 백과사전 (wikipedia.org)

[파이썬 기초] 클래스(Class)

김춘식_123 — Tue, 20 Aug 2024 16:40:28 +0900

다른 사람들이 쓴거 보니까 뭐가 많아서 아주 간단하게 설명하려고 한다 !

어려운 용어 대신 단순 클래스에 대한 이해를 위해 쉽게 쉽게 적었다.

~~(고로 정확하고 제대로 이해하려면 정의에 대한 내용을 직접 찾아보는 것이 좋을 것이다....)~~

클래스(Class)란?

- 객체 지향 프로그래밍의 핵심 개념으로, 데이터와 그 데이터를 처리하는 메서드를 하나의 단위로 묶는 데 사용합니다.

만약 내가 세 사람에 대한 정보를 저장하려고 한다고 가정해봅시다.

(세 사람의 정보는 아래와 같다.)

여기서 대문자 A,B,C를 사용해서 아래 코드 역시 A,B,C를 사용한 것으로 코드에서 불편하다면 소문자 a,b,c를 사용해도 문제 없다.

그럼 클래스를 사용하지 않으면,

# A 
name_1 = "김철수"
gender_1 = "남자"
age_1 = 17

# B
name_2 = "김영희"
gender_2 = "여자"
age_2 = 20

# C
name_3 = "홍길동"
gender_3 = "남자"
age_3 = 12

이런 식이 되겠죠?

근데 상당히 불편하다고 느껴지지 않나요?

같은 형식인데 변수를 하나씩 지정하고 있는건 너무 번거롭죠.

나중에 100명의 정보를 저장할 때는 name_100 = "김첨지" 이러고 있을 걸 생각하면 아찔하죠.

그게 Class를 사용하는 첫번째 이유입니다.

두번째로는, 사실 A라는 항목에 해당하는 name_1, gender_1, age_1 세 개 모두 김철수라는 인물에 대한 내용입니다.

저희는 변수 뒤에 저장되어있는 통일된 1로 그 사실을 알 수 있지만, 막상 컴퓨터에게는 하나하나가 다 다른 객체의 변수일 뿐입니다.

그게 Class를 사용하는 두번째 이유입니다.

클래스를 사용하는 법

클래스에는 우선 클래스명이 지정되어야 합니다.

사람에 대한 정보임으로 클래스명을 우선 Person으로 지정해보겠습니다.

class Person:
    def __init__(self, name, age, gender):
        self.name = name
        self.age = age
        self.gender = gender

이런 구조로 생겼습니다.

그 구조는 바뀌지 않으니 이해가 안되면 머리에 익히면 됩니다.

init?

먼저, __init__에 대해 알아야겠죠?

__init__는 메서드는 클래스의 생성자로, 객체가 생성될 때 호출됩니다.

쉽게 말하면 __init__안에 있는 것들은 자동으로 실행된다는 말입니다.

그럼 클래스를 사용할 때 무조건 사용할 것들을 집어넣으면 편하게 사용할 수 있겠죠?

self ?

그리고 self는 말 그대로 자기 자신(변수)을 말합니다.

한 번 이 클래스를 실행시켜보면 이해가 될 것입니다.

A = Person(name="김철수", gender="남자",age="17")

여기서 A가 self가 되는 것입니다.

만약 B(김영희)를 실행시켜본다면, self는 B가 되겠죠?

이제 A목록 저장은 끝났습니다.

A.name

을 실행해보면 '김철수'가 나오는 것을 확인할 수 있습니다.

매우 간단하죠?

show ?

show()에 대해서 설명해보겠습니다.

Python 클래스에서 객체의 정보를 출력하기 위해 사용되는 메서드로, 주로 객체의 속성을 사용자에게 보여주는 역할을 합니다.

class Person:
    def __init__(self, name, gender, age):
        self.name = name
        self.age = age
        self.gender = gender
    def show(self):
        print("제 이름은 {}이고, 성별은 {}이고, 나이는 {}살입니다.".format(self.name, self.gender, self.age))

당연히 show는 init와 다르게 class를 사용한다고 바로 실행되지 않습니다.

그럼 어떻게 실행하냐면,

A.show()

이렇게 여느 함수처럼 실행하면 됩니다.

그럼 결과가,

'제 이름은 김철수이고, 성별은 남자이고, 나이는 17살입니다.'

라고 나올겁니다.

마지막으로 상속에 대한 간단한 설명을 하겠습니다.

상속 ?

객체 지향 프로그래밍(OOP)에서 코드의 재사용성을 높이고 클래스 간의 관계를 정의하기 위해 사용됩니다.

정의 자체는 어려운 것 같지만 말 그대로 우리가 아는 '상속'의 개념이랑 똑같습니다.

이 사람 정보에서 주소 데이터를 추가해야 한다고 가정해봅시다.

물론 Person 클래스 자체를 수정해도 되겠죠.

하지만 원본은 그대로 두고 Person2라는 클래스를 만들어 상속시키는 것을 추천합니다.

상속시키는 방법은 매우 간단합니다.

괄호 안에 부모클래스(베이스가 될 클래스)를 넣으면 됩니다.

class Person2(Person):
    def __init__(self, name, gender, age, address):
        super().__init__(name, gender, age)
        self.address = address

상속을 하기 위해서는 super에 대해서 알아야합니다.

Super ?

원래 def __init__(): 를 선언하면 기존에 있던 Person의 __init__내용은 초기화됩니다.

근데 저희의 목표는 기존 데이터에서 주소 데이터만 추가하는 것이기 때문에 초기화를 하고 다시 선언할 필요가 없습니다.

그렇다면 기존에 있는 __init__ 내용을 보존해야겠죠?

그것을 위해 super을 사용하는 것입니다.

super().__init__()를 사용하면 Person에 있는 __init__내용이 그대로 저장됩니다.

그리고 우리가 추가할 address 변수만 추가하면 되겠죠?

한 번 추가한 데이터를 포함해서 저장이 잘 되었는지 확인해봅시다.

A = Person2(name="김철수", gender="남자",age="17", address="서울")
A.show()

결과는,

'제 이름은 김철수이고, 성별은 남자이고, 나이는 17살이고, 서울에 거주하고 있습니다.'

라고 나오면 되겠죠?

영희와 길동 내용으로 실습해보는 것을 추천합니다.

[파이토치 딥러닝 마스터] 8장 (3)

김춘식_123 — Mon, 19 Aug 2024 17:23:02 +0900

Github 참조

onlybooks/pytorch: 파이토치 딥러닝 마스터 (github.com)

GitHub - onlybooks/pytorch: 파이토치 딥러닝 마스터

파이토치 딥러닝 마스터. Contribute to onlybooks/pytorch development by creating an account on GitHub.

github.com

개인 공부 할 때 적은 것으로, 코드 위주로 설명됩니다. (추후 내용 추가 될 수 있음)

8장 내용을 다루고 있습니다.

8.5 모델 설계

8.5.1 메모리 용량 늘리기: 너비

가장 먼저 차원 정보 몇 가지를 살펴봐야 한다.

1. 신경망의 너비 차원

-> 신경망 계층 내의 뉴런 수 혹은 컨볼루션의 채널 수에 해당하는 값

파이토치에서는 모델을 쉽게 넓힐 수 있다.

첫 번째 컨볼루션의 출력 채널 수를 더 크게 하고 이어지는 계층도 여기에 맞춰 키워준다.

이렇게 하면 더 길어진 벡터를 가지게 되니 이에 따라 완전 연결 계층으로 전환되는 forward 함수에도 반영한다.

class NetWidth(nn.Module):
    def __init__(self):
        super().__init__()
        self.conv1 = nn.Conv2d(3, 32, kernel_size=3, padding=1)
        self.conv2 = nn.Conv2d(32, 16, kernel_size=3, padding=1)
        self.fc1 = nn.Linear(16 * 8 * 8, 32)
        self.fc2 = nn.Linear(32, 2)
        
    def forward(self, x):
        out = F.max_pool2d(torch.tanh(self.conv1(x)), 2)
        out = F.max_pool2d(torch.tanh(self.conv2(out)), 2)
        out = out.view(-1, 16 * 8 * 8)
        out = torch.tanh(self.fc1(out))
        out = self.fc2(out)
        return out

모델 정의에서 하드코딩을 피하려면 파라미터를 init에 전달하고 너비를 파라미터화해서 forward 함수에서 view를 호출 할 때도 이를 고려한다.

class NetWidth(nn.Module):
    def __init__(self, n_chans1=32):
        super().__init__()
        self.n_chans1 = n_chans1
        self.conv1 = nn.Conv2d(3, n_chans1, kernel_size=3, padding=1)
        self.conv2 = nn.Conv2d(n_chans1, n_chans1 // 2, kernel_size=3,
                               padding=1)
        self.fc1 = nn.Linear(8 * 8 * n_chans1 // 2, 32)
        self.fc2 = nn.Linear(32, 2)
        
    def forward(self, x):
        out = F.max_pool2d(torch.tanh(self.conv1(x)), 2)
        out = F.max_pool2d(torch.tanh(self.conv2(out)), 2)
        out = out.view(-1, 8 * 8 * self.n_chans1 // 2)
        out = torch.tanh(self.fc1(out))
        out = self.fc2(out)
        return out

각 계층에서 채널과 피처의 수를 나타내는 숫자들은 직접적으로 모델의 파라미터 수에 영향을 미친다.

다른 부분이 다 동일한 경우 이러한 변화는 모델의 용량을 증가시킨다.

전에 했던 것처럼 모델이 가진 파라미터가 얼마나 많은지는 다음과 같이 확인 할 수 있다.

sum(p.numel() for p in model.parameters())

결과

38386

용량이 클수록 모델이 다룰 수 있는 입력은 더 다양해진다.

-> 대신 과적합 가능성도 커진다.

(파라미터가 많아져서 입력에서 불필요한 부분까지 기억해버릴 수 있기 때문)

-> 샘플 수를 늘리거나 데이터가 충분하지 않다면 데이터를 인공적으로 수정해서 증강시켜야 한다.

과적합을 제어하기 위해 모델 레벨에서 다룰 수 있는 몇가지 트릭이 있는데 이 중 대표적인 것을 한 번 알아보자.

8.5.2 모델이 수렴하고 일반화하도록 돕는 방법: 정규화

모델 훈련은 중요한 두 단계를 거친다.

1. 최적화 단계

- 훈련셋에 대해 손실값을 줄이는 경우

2. 일반화 단계

- 모델이 훈련셋뿐 아니라 이전에 겪어보지 않은 검증셋 같은 데이터에 대해서도 동작하게 하는 것

-> 두 단계를 위한 수학적 도구를 모아서 정규화(regularization)라는 이름을 붙이기도 한다.

파라미터 제어하기: 가중치 패널티

일반화를 안정적으로 수행하기 위한 첫 번째 방법으로 손실값에 정규화 항을 넣는 방법이 있다.

이 정규화 항을 조작해서 모델의 가중치가 상대적으로 작게 만든다.

-> 훈련을 통해 증가할 수 있는 크기를 제한하는 것

( 큰 가중치 값에 패널티를 부과하는 셈)

-> 손실값은 다소 매끄러운 등고선 형태를 띠는데 개별 샘플에 맞춰서 얻는 이득이 상대적으로 줄어들게 된다.

L2 정규화 (Ridge)

= 가중치 감쇠(weight decay)

- 모델의 모든 가중치에 대한 제곱합

L1 정규화 (Lasso)

- 모델의 모든 가중치 절대값의 합

def training_loop_l2reg(n_epochs, optimizer, model, loss_fn,
                        train_loader):
    for epoch in range(1, n_epochs + 1):
        loss_train = 0.0
        for imgs, labels in train_loader:
            imgs = imgs.to(device=device)
            labels = labels.to(device=device)
            outputs = model(imgs)
            loss = loss_fn(outputs, labels)

            l2_lambda = 0.001
            l2_norm = sum(p.pow(2.0).sum()
                          for p in model.parameters())  # <1>
            loss = loss + l2_lambda * l2_norm

            optimizer.zero_grad()
            loss.backward()
            optimizer.step()
            
            loss_train += loss.item()
        if epoch == 1 or epoch % 10 == 0:
            print('{} Epoch {}, Training loss {}'.format(
                datetime.datetime.now(), epoch,
                loss_train / len(train_loader)))

파이토치의 SGD 옵티마이저에는 이미 weight_decay 파라미터가 있고 2 * lambda 값을 가지며 업데이트 동작시 앞에서 설명한 것처럼 가중치 감쇠를 수행한다.

손실값에 가중치의 L2 정규화를 더한 것과 동일하므로, 자동미분과 손실값에서 항을 누적하는 작업을 할 필요가 있다.

입력 하나에 너무 의존하지 않기: 드랍아웃

드랍아웃

- 훈련을 반복할 때마다 신경망의 뉴런 출력을 랜덤함게 0으로 만드는 작업을 일어나게 하는 것

-> 매 훈련 때마다 조금씩 다른 뉴런의 토폴로지가 만들어지기 때문에 신경망이 각 입력 샘플을암기하려는 기회를 줄이므로 과적합을 방지한다.

파이토치에서는 비선형 활성 함수와 선형 혹은 여러 계층의 컨볼루션 모듈 사이에 nn.Dropout 모듈을 넣어 모델의 드랍아웃을 구현할 수 있다.

인자로는, 어떤 입력이 0이 될지에 대한 확률을 지정해준다.

컨볼루션은 전용 값인 nn.Dropout2D나 nn.Dropout3d를 사용해서 해당 입력값의 채널 전부를 0으로 만든다.

class NetDropout(nn.Module):
    def __init__(self, n_chans1=32):
        super().__init__()
        self.n_chans1 = n_chans1
        self.conv1 = nn.Conv2d(3, n_chans1, kernel_size=3, padding=1)
        self.conv1_dropout = nn.Dropout2d(p=0.4)
        self.conv2 = nn.Conv2d(n_chans1, n_chans1 // 2, kernel_size=3,
                               padding=1)
        self.conv2_dropout = nn.Dropout2d(p=0.4)
        self.fc1 = nn.Linear(8 * 8 * n_chans1 // 2, 32)
        self.fc2 = nn.Linear(32, 2)
        
    def forward(self, x):
        out = F.max_pool2d(torch.tanh(self.conv1(x)), 2)
        out = self.conv1_dropout(out)
        out = F.max_pool2d(torch.tanh(self.conv2(out)), 2)
        out = self.conv2_dropout(out)
        out = out.view(-1, 8 * 8 * self.n_chans1 // 2)
        out = torch.tanh(self.fc1(out))
        out = self.fc2(out)
        return out

드랍아웃은 훈련 중에 활성화되고 훈련이 끝난 모델을 제품으로 사용할 때는 그냥 통과하게 두거나 확률값에 0을 넣어준다.

Dropout 모듈의 train 프로퍼티를 통해 제어하면 된다.

파이토치는 nn.Model 서브클래스에 대해 model.train() 혹은 model.eval() 호출로 전환 가능함을 기억하자.

(이 호출은 서브 모듈에도 자동으로 적용되므로 그중에 Dropout이 있다면 순방향 혹은 역방향 전달시 원하는 대로 모드가 전환되어 동작할 것이다.)

활성 함수 억제하기: 배치 정규화

배치 정규화의 핵심

: 입력 범위를 신경망의 활성 함수로 바꿔서 미니 배치가 원하는 분포를 가지게 하는 것

배치 정규화는 미니 배치 샘플을 통해 중간 위치에서 얻은 평균과 표준편차를 사용하여 중간 입력값을 이동하고 범위를 바꾼다.

-> 모델이 보는 개별 샘플이나 이로 인한 이후의 활성화 단계에서는 랜덤하게 뽑아 만들어진 미니 배치에서 통계에 의존한 값의 이동과 범위 조정이 반영되어 있는 상태 (이자체로 원칙적인 데이터 증강)

class NetBatchNorm(nn.Module):
    def __init__(self, n_chans1=32):
        super().__init__()
        self.n_chans1 = n_chans1
        self.conv1 = nn.Conv2d(3, n_chans1, kernel_size=3, padding=1)
        self.conv1_batchnorm = nn.BatchNorm2d(num_features=n_chans1)
        self.conv2 = nn.Conv2d(n_chans1, n_chans1 // 2, kernel_size=3, 
                               padding=1)
        self.conv2_batchnorm = nn.BatchNorm2d(num_features=n_chans1 // 2)
        self.fc1 = nn.Linear(8 * 8 * n_chans1 // 2, 32)
        self.fc2 = nn.Linear(32, 2)
        
    def forward(self, x):
        out = self.conv1_batchnorm(self.conv1(x))
        out = F.max_pool2d(torch.tanh(out), 2)
        out = self.conv2_batchnorm(self.conv2(out))
        out = F.max_pool2d(torch.tanh(out), 2)
        out = out.view(-1, 8 * 8 * self.n_chans1 // 2)
        out = torch.tanh(self.fc1(out))
        out = self.fc2(out)
        return out

드랍아웃처럼 배치 정규화도 훈련 때와 추론 때는 각기 다르게 동작해야 한다.

추론 시에 출력은 모델이 이미 봤던 다른 입력의 통계에 의존하는 특정 입력을 위한 것이 되어서는 안된다.

8.5.3 더 복잡한 구조를 배우기 위해 깊이 파헤치기: 깊이

앞에서 모델의 용량을 크게 만들기 위해 바꿔야 할 첫 번쨰 차원인 너비에 대해서 설명했다.

두 번째 차원은 깊이(depth)이다.

모델이 깊어질수록 신경망은 더 복잡한 함수에 근사할 수 있다.

깊이를 더한다 = 신경망이 입력을 처리할 때 수행할 연산을 더 길게 나열할 수 있다는 의미

스킵 커넥션

모델에 깊이가 더해질수록 훈련은 수렴하기 어려워진다.

역전파를 매우 깊은 심층 신경망을 수행한다고 가정하면,

파라미터에 대한 손실 함수의 미분은 특히 더 이전 계층의 경우 손실값과 파라미터 사이의 미분 연산의 체인 연결에서 오는 많은 수로 곱해져야 한다.

곱하는 수가 작을 수도 있고, 그래서 정말 작은 값이 만들어지거나 혹은 반대로 큰 값이 만들어지거나 부동소수점 근사 과정에서 작은 값들이 사라져버릴 수도 있다.

-> 곱셈이 체인이 길게 이어지는 경우 기울기값에 기여하는 파라미터가 사라져버려서 파라미터 같은 값들이 적절하게 업데이트되지 않기 때문에 효가 없는 훈련을 초래할 수 있다는 점

단순한 트릭으로 매우 깊은 신경망이어도 성공적으로 훈련되는 잔차 신경망인 레즈넷에 대해서 알아보자.

[1512.03385] Deep Residual Learning for Image Recognition (arxiv.org)

Deep Residual Learning for Image Recognition

Deeper neural networks are more difficult to train. We present a residual learning framework to ease the training of networks that are substantially deeper than those used previously. We explicitly reformulate the layers as learning residual functions with

arxiv.org

스킵 커넵션

- 입력을 계층 블럭의 출력에 연결하는 것으로서, 파이토치에서 수행 가능

class NetDepth(nn.Module):
    def __init__(self, n_chans1=32):
        super().__init__()
        self.n_chans1 = n_chans1
        self.conv1 = nn.Conv2d(3, n_chans1, kernel_size=3, padding=1)
        self.conv2 = nn.Conv2d(n_chans1, n_chans1 // 2, kernel_size=3,
                               padding=1)
        self.conv3 = nn.Conv2d(n_chans1 // 2, n_chans1 // 2,
                               kernel_size=3, padding=1)
        self.fc1 = nn.Linear(4 * 4 * n_chans1 // 2, 32)
        self.fc2 = nn.Linear(32, 2)
        
    def forward(self, x):
        out = F.max_pool2d(torch.relu(self.conv1(x)), 2)
        out = F.max_pool2d(torch.relu(self.conv2(out)), 2)
        out = F.max_pool2d(torch.relu(self.conv3(out)), 2)
        out = out.view(-1, 4 * 4 * self.n_chans1 // 2)
        out = torch.relu(self.fc1(out))
        out = self.fc2(out)
        return out

레즈넷처럼 스킵 커넥션을 이 모델에 추가하는 것은 forward 함수의 첫 번쨰 계층의 출력을 세 번째 계층의 입력에 추가하는 것과 같다.

class NetRes(nn.Module):
    def __init__(self, n_chans1=32):
        super().__init__()
        self.n_chans1 = n_chans1
        self.conv1 = nn.Conv2d(3, n_chans1, kernel_size=3, padding=1)
        self.conv2 = nn.Conv2d(n_chans1, n_chans1 // 2, kernel_size=3,
                               padding=1)
        self.conv3 = nn.Conv2d(n_chans1 // 2, n_chans1 // 2,
                               kernel_size=3, padding=1)
        self.fc1 = nn.Linear(4 * 4 * n_chans1 // 2, 32)
        self.fc2 = nn.Linear(32, 2)
        
    def forward(self, x):
        out = F.max_pool2d(torch.relu(self.conv1(x)), 2)
        out = F.max_pool2d(torch.relu(self.conv2(out)), 2)
        out1 = out
        out = F.max_pool2d(torch.relu(self.conv3(out)) + out1, 2)
        out = out.view(-1, 4 * 4 * self.n_chans1 // 2)
        out = torch.relu(self.fc1(out))
        out = self.fc2(out)
        return out

바꿔 말하면 표준 피드포워드 경로에 추가적으로 첫 번째 활성 함수의 출력을 마지막 부분의 입력으로 사용하는 것이다.

=> 아이덴티티 매핑(identity mapping)이라고도 부른다.

역전파를 생각해보면 스킵 커넥션 혹은 심층 신경망에서의 연속적인 스킵 커넥션은 깊은 쪽에 있는 파라미터를 손실값에 연결하는 역할을 한다.

-> 체인으로 길게 연결된 여러 다른 연산들로 곱해질 기회가 줄어들고, 파라미터에 대한 손실값의 편미분으로 손실값에 대한 기울기에 더욱 직접적으로 관여

스킵 커넥션이 특히 훈련의 초반 단계에서 수렴에 도움이 되는 방향으로 작용하는 것을 발견

(잔차 신경망의 손실값 분포는 동일한 깊이나 너비를 가진 피드포워드 신경망보다 훨씬 부드럽다.)

파이토치로 매우 깊은 모델 만들기

먼저 컨볼루션과 활성 함수, 스킵 커넥션으로 이뤄진 블럭을 위한 연산을 제공하는 모듈 서브클래스를 정의한다.

class ResBlock(nn.Module):
    def __init__(self, n_chans):
        super(ResBlock, self).__init__()
        self.conv = nn.Conv2d(n_chans, n_chans, kernel_size=3,
                              padding=1, bias=False)  # <1>
        self.batch_norm = nn.BatchNorm2d(num_features=n_chans)
        torch.nn.init.kaiming_normal_(self.conv.weight,
                                      nonlinearity='relu')  # <2>
        torch.nn.init.constant_(self.batch_norm.weight, 0.5)
        torch.nn.init.zeros_(self.batch_norm.bias)

    def forward(self, x):
        out = self.conv(x)
        out = self.batch_norm(out)
        out = torch.relu(out)
        return out + x

깊은 모델을 만들기로 했으므로 블럭에 배치 정규화를 넣어 훈련 도중에 기울기 값이 없어지는 것을 방지한다.

이제 이 블럭을 100개 가진 신경망을 만들어보자.

class NetResDeep(nn.Module):
    def __init__(self, n_chans1=32, n_blocks=10):
        super().__init__()
        self.n_chans1 = n_chans1
        self.conv1 = nn.Conv2d(3, n_chans1, kernel_size=3, padding=1)
        self.resblocks = nn.Sequential(
            *(n_blocks * [ResBlock(n_chans=n_chans1)]))
        self.fc1 = nn.Linear(8 * 8 * n_chans1, 32)
        self.fc2 = nn.Linear(32, 2)
        
    def forward(self, x):
        out = F.max_pool2d(torch.relu(self.conv1(x)), 2)
        out = self.resblocks(out)
        out = F.max_pool2d(out, 2)
        out = out.view(-1, 8 * 8 * self.n_chans1)
        out = torch.relu(self.fc1(out))
        out = self.fc2(out)
        return out

실험과 재사용성을 고려하여 계층의 수를 파라미터로 지정할 수 있도록 만들었다.

신경망이 수렴하는데 꽤 시간이 걸릴 것이고, 잘 안될 수도 있다.

그래서 초기화를 더 꼼꼼하게 진행한 후 NetRes를 훈련시키되 학습률도 다른 신경망에서 사용하던 1e - 2 대신 3e - 3을 썼다.

초기화

초기화는 신경망 훈련의 중요한 방법 중 하나다.

완전히 개선되기 전까지는 가중치 초기화를 직접 고쳐야 한다.

일반적인 초기화 방법(가중치 변화량 감소와 배치 정규화를 위한 평균값 0과 단위 분산 출력 등)

[파이토치 딥러닝 마스터] 8장 (2)

김춘식_123 — Tue, 13 Aug 2024 16:10:44 +0900

Github 참조

onlybooks/pytorch: 파이토치 딥러닝 마스터 (github.com)

GitHub - onlybooks/pytorch: 파이토치 딥러닝 마스터

파이토치 딥러닝 마스터. Contribute to onlybooks/pytorch development by creating an account on GitHub.

github.com

개인 공부 할 때 적은 것으로, 코드 위주로 설명됩니다. (추후 내용 추가 될 수 있음)

8장 내용을 다루고 있습니다.

8.3 nn.Module 서브클래싱하기

8.3.1 nn.Module로 정의된 우리의 신경망

class Net(nn.Module):
    def __init__(self):
        super().__init__()
        self.conv1 = nn.Conv2d(3, 16, kernel_size=3, padding=1)
        self.act1 = nn.Tanh()
        self.pool1 = nn.MaxPool2d(2)
        self.conv2 = nn.Conv2d(16, 8, kernel_size=3, padding=1)
        self.act2 = nn.Tanh()
        self.pool2 = nn.MaxPool2d(2)
        self.fc1 = nn.Linear(8 * 8 * 8, 32)
        self.act3 = nn.Tanh()
        self.fc2 = nn.Linear(32, 2)

    def forward(self, x):
        out = self.pool1(self.act1(self.conv1(x)))
        out = self.pool2(self.act2(self.conv2(out)))
        out = out.view(-1, 8 * 8 * 8) # 앞에서 놓쳤던 차원 정보 변경
        out = self.act3(self.fc1(out))
        out = self.fc2(out)
        return out

Net 클래스는 앞에서 만들었던 nn.Sequential 모델과 같은 서브모듈이다.

다만 명시적으로 forward 함수를 작성했기 때문에 self.pool3의 출력을 직접 조작해서 view를 통해 B x N 벡터로 만들 수 있다.

배치에 얼마나 많은 샘플이 들어있을지 알 수 없기 때문에 view 호출시 배치 차원을 -1로 두었다.

nn.Module의 서브클래스는 모델 전체를 담는데 활용했다.

더 복잡한 신경망을 위한 새로운 빌딩 블럭을 정의하기 위해 이 서브클래스를 사용할 수도 있다.

어디에 어떤 정보를 표현할지는 임의로 정해서 그린 것

분류 신경망의 목적

- 큰 수의 픽셀을 가진 이미지에서 출발해 정보를 압축해가면서 분류 클래스로 만들어 가는 것

1. 중간에 나타나는 값의 개수가 점점 줄어드는 모습에 우리가 목표하는 바가 반영되어있다.

컨볼루션의 채널 수가 점점 줄어들고 풀링에서 픽셀 수가 줄어들며 선형 계층에서는 입력 차원보다 낮은 수의 차원을 출력한다.

-> 분류 신경망의 전형적인 특징

2. 최초의 컨볼루션에서는 입력 크기에 대해 출력 크기가 줄어들지 않는다.

8.3.2 파이토치가 파라미터와 서브모듈을 유지하는 방법

생성자 안에서 nn.Module의 속성에 nn.Module의 인스턴스를 할당했었다.

이렇게 하면, 모듈이 서브모듈로 등록된다.

nn.Module 서브클래스의 메소드라면 언제나 호출 가능하다.

이런 메소드의 호출은 모듈 자체보다는 forward 메소드를 호출하는 것과 비슷해서, hook 호출을 놓치게 되고 JIT는 사용시 모듈 구조를 볼 수 없다.

이렇게 하면 Net은 사용자의 추가 행위 없이 서브모듈의 파라미터에 접근할 수 있게 된다.

model = Net()

numel_list = [p.numel() for p in model.parameters()]
sum(numel_list), numel_list

코드의 parameter() 호출은 생성자에서 속성으로 할당된 모든 서브모듈을 찾아 이들의 parameters()를 재귀적으로 호출한다.

서브모듈이 얼마나 중첩되어 있든지 간에 어떤 nn.Module도 모든 자식 파라미터의 리스트에 접근 할 수 있다.

옵티마이저는 autograd로 얻을 수 있는 이들의 grad 속성에 접근해서 손실값을 줄이기 위해 파라미터를 어떻게 바꿔야 하는지 알 수 있다.

8.3.3 함수형 API

파이토치는 모든 nn 모듈에 대한 함수형을 제공한다.

함수형 = 내부 상태가 없다는 의미

-> 출력값이 전적으로 입력 인자에 의존한다.

모듈에 저장된 파라미터와 입력 인자로 동작하는 것과는 달리 함수형이므로, 호출시 인자로 입력값 외에 파라미터도 받는다.

import torch.nn.functional as F

class Net(nn.Module):
    def __init__(self):
        super().__init__()
        self.conv1 = nn.Conv2d(3, 16, kernel_size=3, padding=1)
        self.conv2 = nn.Conv2d(16, 8, kernel_size=3, padding=1)
        self.fc1 = nn.Linear(8 * 8 * 8, 32)
        self.fc2 = nn.Linear(32, 2)
        
    def forward(self, x):
        out = F.max_pool2d(torch.tanh(self.conv1(x)), 2)
        out = F.max_pool2d(torch.tanh(self.conv2(out)), 2)
        out = out.view(-1, 8 * 8 * 8)
        out = torch.tanh(self.fc1(out))
        out = self.fc2(out)
        return out

8.3.1절에서 정의한 Net과 동일하지만 훨씬 더 간결하다.

8.3.1 절 코드

class Net(nn.Module):
    def __init__(self):
        super().__init__()
        self.conv1 = nn.Conv2d(3, 16, kernel_size=3, padding=1)
        self.act1 = nn.Tanh()
        self.pool1 = nn.MaxPool2d(2)
        self.conv2 = nn.Conv2d(16, 8, kernel_size=3, padding=1)
        self.act2 = nn.Tanh()
        self.pool2 = nn.MaxPool2d(2)
        self.fc1 = nn.Linear(8 * 8 * 8, 32)
        self.act3 = nn.Tanh()
        self.fc2 = nn.Linear(32, 2)

    def forward(self, x):
        out = self.pool1(self.act1(self.conv1(x)))
        out = self.pool2(self.act2(self.conv2(out)))
        out = out.view(-1, 8 * 8 * 8) # 앞에서 놓쳤던 차원 정보 변경
        out = self.act3(self.fc1(out))
        out = self.fc2(out)
        return out

이제 모델이 동작하는지 점검해보자.

model = Net()
model(img.unsqueeze(0))

결과

tensor([[-0.0157, 0.1143]], grad_fn=<AddmmBackward>)

훌륭하다.

더 복잡한 모델에서는 최초의 선형 계층의 크기를 정확하게 잡는 부분이 모든 문제를 해결하는 근원이 되기도 한다.

8.4 우리가 만든 컨볼루션 신경망 훈련시키기

우리가 만든 컨볼루션 신경망은 중첩된 두 루프를 가지고 있음을 주목

바깥 루프: 에포크 단위

안쪽 루프: Dataset에서 배치를 만드는 DataLoader 단위

각 루프에서,

1. 모델에 입력값을 넣고 (순방향 전달)

2. 손실값을 계산하고 (순방향 전달)

3. 이전 기울기값을 0으로 리셋하고

4. loss.backward()를 호출하여 모든 파라미터에 대한 손실값의 기울기를 계산 (역방향 전달)

5. 이후 옵티마이저를 통해 손실값을 낮추도록 파라미터 조정

훈련 루프는 7장과 동일하지만 주석을 읽어보면 좋을 것이다.

import datetime  # 파이썬에 포함된 datatime 모듈을 사용함

def training_loop(n_epochs, optimizer, model, loss_fn, train_loader):
    for epoch in range(1, n_epochs + 1):  # 에포크 숫자는 0 대신, 1부터 n_epochs까지 루프를 돌며 부여함
        loss_train = 0.0
        for imgs, labels in train_loader:  # 데이터 로더가 만들어준 배치 안에서 데이터셋을 순회함
            
            outputs = model(imgs)  # 모델에 배치를 넣어줌
            
            loss = loss_fn(outputs, labels)  # 최소화하려는 손실값을 계산

            optimizer.zero_grad()  # 마지막에 이전 기울기 값을 지움
            
            loss.backward()  # 역전파 수행 (신경망이 학습할 모든 파라미터에 대한 기울기 계산)
            
            optimizer.step()  # 모델 업데이트

            loss_train += loss.item()  # 에포크 동안 확인한 손실값을 모두 더한다.
                                       # 기울기값을 꺼내고자 .item()을 사용해 손실값을 파이썬 수로 변환하는 것

        if epoch == 1 or epoch % 10 == 0:
            print('{} Epoch {}, Training loss {}'.format(
                datetime.datetime.now(), epoch,
                loss_train / len(train_loader)))  # 배치 단위의 평균 손실값을 구하기 위해 훈련 데이터 로더의 길이로 나눈다
                                                  # 이 값이 총합보다 훨씬 직관적

7장과 다른점:

모델이 커스텀 nn.Module 서브 클래스를 통해 컨볼루션을 사용한다는 점

~~(아래 코드는 꽤 오래 걸릴 수도 있다. 너무 오래 걸리면 epoch를 줄여보는 수도... 대부분은 3분 안에 끝날 것이다.)~~

train_loader = torch.utils.data.DataLoader(cifar2, batch_size=64,
                                           shuffle=True)  # <1>

model = Net()  #  <2>
optimizer = optim.SGD(model.parameters(), lr=1e-2)  #  <3>
loss_fn = nn.CrossEntropyLoss()  #  <4>

training_loop(  # <5>
    n_epochs = 100,
    optimizer = optimizer,
    model = model,
    loss_fn = loss_fn,
    train_loader = train_loader,
)

결과

2020-01-16 23:07:21.889707 Epoch 1, Training loss 0.5634813266954605
2020-01-16 23:07:37.560610 Epoch 10, Training loss 0.3277610331109375
2020-01-16 23:07:54.966180 Epoch 20, Training loss 0.3035225479086493
2020-01-16 23:08:12.361597 Epoch 30, Training loss 0.28249378549824855
2020-01-16 23:08:29.769820 Epoch 40, Training loss 0.2611226033253275
2020-01-16 23:08:47.185401 Epoch 50, Training loss 0.24105800626574048
2020-01-16 23:09:04.644522 Epoch 60, Training loss 0.21997178820477928
2020-01-16 23:09:22.079625 Epoch 70, Training loss 0.20370126601047578
2020-01-16 23:09:39.593780 Epoch 80, Training loss 0.18939699422401987
2020-01-16 23:09:57.111441 Epoch 90, Training loss 0.17283396527266046
2020-01-16 23:10:14.632351 Epoch 100, Training loss 0.1614033816868712

8.4.1 정확도 측정

train_loader = torch.utils.data.DataLoader(cifar2, batch_size=64,
                                           shuffle=False)
val_loader = torch.utils.data.DataLoader(cifar2_val, batch_size=64,
                                         shuffle=False)

def validate(model, train_loader, val_loader):
    for name, loader in [("train", train_loader), ("val", val_loader)]:
        correct = 0
        total = 0

        with torch.no_grad():  # 파라미터를 업데이트하지 않을 것이므로 기울기 필요 X
            for imgs, labels in loader:
                outputs = model(imgs)
                _, predicted = torch.max(outputs, dim=1) # 가장 높은 값을 가진 인덱스를 출력
                total += labels.shape[0]  # 예제 수를 세어서 total을 배치 크기만큼 증가
                correct += int((predicted == labels).sum())  
                
        print("Accuracy {}: {:.2f}".format(name , correct / total))

validate(model, train_loader, val_loader)

결과

Accuracy train: 0.93
Accuracy val: 0.89

정수 텐서를 파이썬 int 형으로 캐스팅한다.

훈련 루프에서 했던 .item()을 사용한 것과 같다.

완전 연결 모델보다 성능이 좋아진 것을 볼 수 있다.

8.4.2 모델을 저장하고 불러오기

그럼 저장해보자!

torch.save(model.state_dict(), data_path + 'birds_vs_airplanes.pt')

birds_vs_airplanes.pt 파일에는 model의 모든 파라미터가 들어 있다.

두 개의 컨볼루션 모듈과 두 개의 선형 모델에 포함된 가중치와 편향값을 저장하고 있으며, 모델 구조는 포함되어 있지 않다.

따라서, 실제 서비스 목적으로 제공한다면 model클래스도 보관해뒀다가 인스턴스를 만들고 파라미터를 파일에서 읽어와야 한다.

loaded_model = Net()
loaded_model.load_state_dict(torch.load(data_path
                                        + 'birds_vs_airplanes.pt'))

↓ pt 파일 다운 주소

pytorch/data/p1ch6/birds_vs_airplanes.pt at master · onlybooks/pytorch (github.com)

pytorch/data/p1ch6/birds_vs_airplanes.pt at master · onlybooks/pytorch

파이토치 딥러닝 마스터. Contribute to onlybooks/pytorch development by creating an account on GitHub.

github.com

8.4.3 GPU에서 훈련시키기

gpu 연결

device = (torch.device('cuda') if torch.cuda.is_available()
          else torch.device('cpu'))
print(f"Training on device {device}.")

아래는 gpu를 사용하게 수정된 코드이다.

import datetime

def training_loop(n_epochs, optimizer, model, loss_fn, train_loader):
    for epoch in range(1, n_epochs + 1):
        loss_train = 0.0
        for imgs, labels in train_loader:
            imgs = imgs.to(device=device)
            labels = labels.to(device=device)
            outputs = model(imgs)
            loss = loss_fn(outputs, labels)

            optimizer.zero_grad()
            loss.backward()
            optimizer.step()

            loss_train += loss.item()

        if epoch == 1 or epoch % 10 == 0:
            print('{} Epoch {}, Training loss {}'.format(
                datetime.datetime.now(), epoch,
                loss_train / len(train_loader)))

train_loader = torch.utils.data.DataLoader(cifar2, batch_size=64,
                                           shuffle=True)

model = Net().to(device=device) 
optimizer = optim.SGD(model.parameters(), lr=1e-2)
loss_fn = nn.CrossEntropyLoss()

training_loop(
    n_epochs = 100,
    optimizer = optimizer,
    model = model,
    loss_fn = loss_fn,
    train_loader = train_loader,
)

결과

2020-01-16 23:10:35.563216 Epoch 1, Training loss 0.5717791349265227
2020-01-16 23:10:39.730262 Epoch 10, Training loss 0.3285350770137872
2020-01-16 23:10:45.906321 Epoch 20, Training loss 0.29493294959994637
2020-01-16 23:10:52.086905 Epoch 30, Training loss 0.26962305994550134
2020-01-16 23:10:56.551582 Epoch 40, Training loss 0.24709946277794564
2020-01-16 23:11:00.991432 Epoch 50, Training loss 0.22623272664892446
2020-01-16 23:11:05.421524 Epoch 60, Training loss 0.20996672821462534
2020-01-16 23:11:09.951312 Epoch 70, Training loss 0.1934866009719053
2020-01-16 23:11:14.499484 Epoch 80, Training loss 0.1799132404908253
2020-01-16 23:11:19.047609 Epoch 90, Training loss 0.16620008706761774
2020-01-16 23:11:23.590435 Epoch 100, Training loss 0.15667157247662544

파이토치는 가중치를 저장할 때 어떤 디바이스를 기억해뒀다가 반대로 읽어들일 때도 해당 디바이스를 사용하므로, GPU에 있던 가중치는 나중에 GPU로 복구될 것이다.

나중에 어떤 디바이스에서 돌릴지 모르니, 신경망을 CPU로 옮긴 후에 저장하든가 아니면 파일에서 읽어들인 후 CPU로 옮기든가 해야 한다.

→ 가중치를 로딩할 때 파이토치가 기억하는 디바이스 정보를 덮어쓰면 된다.

loaded_model = Net().to(device=device)
loaded_model.load_state_dict(torch.load(data_path
                                        + 'birds_vs_airplanes.pt',
                                        map_location=device))

결과

[파이토치 딥러닝 마스터] 8장 (1)

김춘식_123 — Mon, 12 Aug 2024 15:25:07 +0900

Github 참조

onlybooks/pytorch: 파이토치 딥러닝 마스터 (github.com)

GitHub - onlybooks/pytorch: 파이토치 딥러닝 마스터

파이토치 딥러닝 마스터. Contribute to onlybooks/pytorch development by creating an account on GitHub.

github.com

개인 공부 할 때 적은 것으로, 코드 위주로 설명됩니다. (추후 내용 추가 될 수 있음)

8장 내용을 다루고 있습니다.

8.1 컨볼루션

8.1.1 컨볼루션의 역할

지역화된 패턴이 이미지의 어떤 위치에 있더라도 동일하게 출력에 영향을 주는 성질을 평행이동 불변성이라 했다.

가중치 행렬의 대부분은 0이 될 것이고, 입력에 대해 상대적으로 같은 위치에 있는 엔트리가 출력 픽셀에 동일한 영향을 줄 방법을 찾아야 한다.

= 같은 값으로 초기화해야 하며 그래스 이 경우와 관련된 가중치가 훈련을 통해 업데이트시 영향을 받지 않아야 한다는 의미다.

-> 이런 식으로 지역 패턴에 대응하여 가중치는 반응하고, 해당 패턴이 이미지의 어디에 존재하든지 파악할 수 있다.

이미지에 대한 지역적인, 평행이동 불변성을 보장하는 선형 연산이 존재하는데, 이것이 바로 컨볼루션(convolution)이다.

이산 컨볼루션은 2차원 이미지에 가중치 행렬을 스칼라곱을 수행하는 것으로 정의한다.

가중치 행렬은 커널이라 부르며 입력의 모든 이웃에 대해 수행한다.

(커널: 입력 데이터에 특정 연산을 적용하기 위한 작은 행렬)

Unsupervised Feature Learning and Deep Learning Tutorial (stanford.edu)

위에 있는 그림에서 커널은 노란색 3x3 행렬이 될 것이다!

컨볼루션을 사용하면,

주위 영역에 대한 지역 연산을 할 수 있고,
평행이동 불면성을 가지며,
더 적은 파라미터를 사용한다.

(더 적은 파라미터만 쓰는 이유는 이전의 완전 연결 계층과는 달리 컨볼루션에서의 파라미터 수는 이미지 픽셀 수에 의존하지 않기 때문, 대신 컨볼루션 커널의 크기와 모델에서 얼마나 많은 컨볼루션 필터를 쓰는지에 의존)

8.2 컨볼루션 사용해보기

torch.nn 모듈은 1,2,3차원에 대한 컨볼루션을 제공한다.

nn.Conv1d는 시계열용이고 nn.Conv2d는 이미지용이며 nn.Conv3d는 용적 데이터나 동영상용이다.

CIFAR-10 데이터에 대해서는 nn.Conv2d를 사용한다.

nn.Conv2d에 전달하는 인자는 최소 입력 피처수와 출력 피처 수, 커널의 크기가 있어야 한다.

첫 컨볼루션 모듈은 RGB 채널을 가지니 픽셀당 3개의 입력 피처를 가지고 출력 피처는 임의로 16을 전달하자.

출력 이미지가 더 많은 채널을 가질수록 신경망의 용량도 커진다.

일단 커널의 크기를 3 X 3으로 정한다.

커널의 크기는 일반적으로 모든 방향으로 동일하게 만든다.

편의상 kernel_size=3으로 지정하면,

2차원 컨볼루션에 대해 3 X 3으로 인식하고,

3차원 컨볼루션에 대해 3 X 3 X 3으로 인식한다.

conv = nn.Conv2d(3, 16, kernel_size=3) 
conv

결과

Conv2d(3, 16, kernel_size=(3, 3), stride=(1, 1))

커널이 3 X 3이므로 가중치 역시 3 X 3을 사용한다.

출력 픽셀 하나에 대해 커널은 입력 채널이 in_ch = 3이므로 출력 픽셀 값 하나에 대해 in_ch X 3 X 3이 된다.

그리고 이 값을 출력 채널만큼 가지게 되어 out_ch =16이므로 전체 가중치 텐서는 out_ch X in_cn X 3 X 3 이 된다.(16 X 3 X 3 X 3)

conv.weight.shape, conv.bias.shape

결과

(torch.Size([16, 3, 3, 3]), torch.Size([16]))

이미지 학습에 컨볼루션이 얼마나 유용한지 확인할 수 있다.

전체 이미지를 돌며 해당 가중치를 최적화하기 위해 부분 패턴을 찾는 훨씬 더 작은 모델을 만들었다.

2차원 컨볼루션 전달은 2차원 이미지를 출력한다.

여기서 출력 픽셀은 입력 이미지의 각 이웃 데이터에 대한 가중치의 합이다.

커널 가중치와 평향값 conv.weight가 랜덤으로 초기화된다.

따라서 출력 이미지 자체가 특별한 의미를 갖지 않는다.

img, _ = cifar2[0]
output = conv(img.unsqueeze(0))
img.unsqueeze(0).shape, output.shape

결과

(torch.Size([1, 3, 32, 32]), torch.Size([1, 16, 30, 30]))

plt.figure(figsize=(10, 4.8))  # bookskip
ax1 = plt.subplot(1, 2, 1)   # bookskip
plt.title('output')   # bookskip
plt.imshow(output[0, 0].detach(), cmap='gray')
plt.subplot(1, 2, 2, sharex=ax1, sharey=ax1)  # bookskip
plt.imshow(img.mean(0), cmap='gray')  # bookskip
plt.title('input')  # bookskip
plt.savefig('Ch8_F2_PyTorch.png')  # bookskip
plt.show()

결과

근데 output 크기가 좀 이상하다?

8.2.1 경계 패딩하기

출력 이미지가 입력 이미지보다 작은 것은 이미지의 경계에서 이루어지는 작업에 따른 부작용이다.

3 X 3 이웃 영역에 대해 컨볼루션 커널을 가중치 합으로 적용하려면 일단 모든 방향에 값이 존재한다는 가정이 있어야 한다.

파이토치에서는 컨볼루션 커널을 입력 그림 안에서 미끌어지며 이동하는데, 수평과 수직 위치는 sidth - kernel_sidth + 1로 구한다.

따라서 크기가 홀수인 컨볼루션 커널의 길이의 절반만큼 양쪽의 그림이 잘린다.

파이토치에서는 이미지의 경계에 값이 0인 가짜 픽셀을 패딩해주는 기능을 제공

A guide to convolution arithmetic for deep learning ❘ 텐서 플로우 블로그 (Tensor ≈ Blog) (tensorflow.blog)

위 그림에서 하얀 부분이 값이 0인 패딩 부분이 될 것이다.

conv = nn.Conv2d(3, 1, kernel_size=3, padding=1) # <1>
output = conv(img.unsqueeze(0))
img.unsqueeze(0).shape, output.shape

결과

(torch.Size([1, 3, 32, 32]), torch.Size([1, 1, 32, 32]))

패딩의 사용 여부와 상관 없이 weight과 bias의 크기는 변하지 않는다.

8.2.2 컨볼루션으로 피처 찾아내기

원래 weight나 bias는 역전파를 통해 학습되는 파라미터다.

하지만?

직접 가중치를 설정해서 컨볼루션에서 무슨 일이 일어나는지 알아보자!

1. bias를 0으로 제거해 교란 변수를 배제하자.

2. 가중치에 상수값을 넣어서 출력에서의 각 픽셀이 자신의 아웃 픽셀에 대한 평균을 가지게 해보자.

3x3에 대한 코드

with torch.no_grad():
    conv.bias.zero_()
    
with torch.no_grad():
    conv.weight.fill_(1.0 / 9.0)

출력 이미지의 값이 0배 커지는 점 외에는 차이가 없다.

CIFAR 이미지에 미친 영향 확인

output = conv(img.unsqueeze(0))
plt.imshow(output[0, 0].detach(), cmap='gray')
plt.show()

결과

패딩하기 전에 위에 결과에서 잘렸던 것이 괜찮아진 것도 확인할 수 있다.

각 출력 픽셀은 자신의 주변 픽셀에 대한 평균이기 때문에 출력 픽셀에서 이러한 상관관계를 반영해 픽셀 간의 변화가 부드러워졌다.

다음으로 커널을 바꿔보자.

conv = nn.Conv2d(3, 1, kernel_size=3, padding=1)

with torch.no_grad():
    conv.weight[:] = torch.tensor([[-1.0, 0.0, 1.0],
                                   [-1.0, 0.0, 1.0],
                                   [-1.0, 0.0, 1.0]])
    conv.bias.zero_()

앞에서 일반 컨볼루션 커널로 했던 것처럼 아무 위치나 잡아 가중치의 합을 구한다고 치면 위치 2,2에 대해 다음 값을 얻는다.

o22 = i13 - i11 +

i23 - i21 +

i33 - i31 +

이 커널은 i22의 오른쪽 픽셀에서 i22의 왼쪽 픽셀을 빼는 계산을 수행

만약,

이미지에서 강도가 다른 두 인접한 영역 사이에서 수직 경계에 커널이 적용되면, o22는 높은 값을 가질 것이다.

반면,

거의 비슷한 색이나 밀도로 이뤄진 영역에서 수행되면 o22는 0이 된다.

-> 이 커널은 가로로 인접한 두 영역 사이의 수직 경계를 탐색하는 역할을 한다.

output = conv(img.unsqueeze(0))
plt.figure(figsize=(10, 4.8))  # bookskip
ax1 = plt.subplot(1, 2, 1)   # bookskip
plt.title('output')   # bookskip
plt.imshow(output[0, 0].detach(), cmap='gray')
plt.subplot(1, 2, 2, sharex=ax1, sharey=ax1)  # bookskip
plt.imshow(img.mean(0), cmap='gray')  # bookskip
plt.title('input')  # bookskip
plt.savefig('Ch8_F5_PyTorch.png')  # bookskip
plt.show()

결과

8.2.3 깊이와 풀링으로 한 단계 더 인식하기

만약 내 그림이 꽤 크다면 어떻게 해야 할까?

-> 더 큰 컨볼루션 커널을 사용하자.

-> 완전 연결된 아핀 변환으로 수렴해서 컨볼루션의 장점을 잃어버린다.

-> 컨볼루션을 차례로 층층히 쌓으면서 동시에 연속적인 컨볼루션 사이의 이미지를 다운샘플링하는 방법 사용

다운 샘플링

- 이미지를 반으로 줄이는 것은 이웃하는 네 개의 픽셀을 입력받아 한 픽셀을 출력하는 작업과 동일

네 개의 픽셀을 평균하기

- 평균 풀링이라는 방법이 일반적이었으나 요즘은 사용 X

네 개의 픽셀 중 최댓값

- 맥스 풀링은 오늘날 가장 널리 사용되지만, 데이터의 4분의 3을 버린다는 단점 존재

스트라이드하며 컨볼루션을 수행하되 n번째 픽셀만 계산하기

- 3x4 컨볼루션을 스트라이드 2로 실행하면 이전 계층의 모든 픽셀을 포함한다. (맥스 풀링을 대체할 정도는 X)

맥스 풀링

다른 선형 계층처럼 활성 함수로 연결되므로 컨볼루션층의 출력 이미지의 각 값은 특정 커널에 대응하는 패턴이 발견될 때 높은 값을 가진다.

다운샘플링을 통해 2x2 인접 픽셀에서 최댓값을 뽑는 것은 약한 신호는 버리고 살아남은 피처를 발견하는 과정으로 볼 수 있다.

맥스 풀링은 nn.MaxPool2d 모듈이 있다.

pool = nn.MaxPool2d(2) # 이미지를 절반으로 줄이고 싶다면 2
output = pool(img.unsqueeze(0))

img.unsqueeze(0).shape, output.shape

결과

(torch.Size([1, 3, 32, 32]), torch.Size([1, 3, 16, 16]))

절반 줄어든 것을 확인 할 수 있따.

더 나은 성능을 위해 컨볼루션과 다운샘플링 결합하기

8.2.4 우리의 신경망에 적용하기

전부터 하던 새와 비행기를 탐지하는 컨볼루션 신경망을 만들어보자.

nn.Conv2d와 nn.MaxPool2d를 활용하자.

model = nn.Sequential(
            nn.Conv2d(3, 16, kernel_size=3, padding=1),
            nn.Tanh(),
            nn.MaxPool2d(2),
            nn.Conv2d(16, 8, kernel_size=3, padding=1),
            nn.Tanh(),
            nn.MaxPool2d(2),
            # . . . 뭔가 빠졌는데?
            nn.Linear(8 * 8 * 8, 32),
            nn.Tanh(),
            nn.Linear(32, 2))
            )

1차원 벡터로 바꿔서 완전 연결 계층으로 신경망 마무리

아래는 신경망을 구현한 코드이다.

코드에서 깜빡한 부분이 있다.

8 채널의 8x8 이미지를, 523 요소를 가진 1차원 벡터로 차원 변경해야 한다.

-> 마지막 nn.MaxPool2d의 출력에 대해 view를 호출하면 해결 할 수 있다.

(nn.Sequential을 사용할 때는 각 모듈의 출력을 명시적으로 볼 수 없다.)

[파이토치 딥러닝 마스터] 7장 (2)

김춘식_123 — Mon, 5 Aug 2024 11:34:56 +0900

Github 참조

onlybooks/pytorch: 파이토치 딥러닝 마스터 (github.com)

GitHub - onlybooks/pytorch: 파이토치 딥러닝 마스터

파이토치 딥러닝 마스터. Contribute to onlybooks/pytorch development by creating an account on GitHub.

github.com

개인 공부 할 때 적은 것으로, 코드 위주로 설명됩니다. (추후 내용 추가 될 수 있음)

7장 내용을 다루고 있습니다.

7.2.5 분류를 위한 손실값

0.0이나 1.0이 아닌 모든 경우를 애써가며 벌점을 주는 대신 분류가 어긋날 경우에 벌점을 주고 싶다.

out이 소프트맥스의 추력이면서 class_index가 '비행기'일 때는 0이고, '새'일 때는 1을 포함하는 벡터라고 할 경우, 이제 정답 클래스 out[class_index]와 관련된 확률을 극대화할 필요가 있다.

정답 클래스에 대한 확률 수치를 가능도(likelihood)라고 한다.

가능도 ↑

- 다른 클래스의 확률이 매우 높을 때 값이 커지는 손실 함수가 필요하다.

가능도 ↓

- 손실값은 낮아야 한다. 확률값을 억지로 1까지 끌어올리는데 집착할 필요가 없다.

이런식으로 동작하는 손실함수가 바로 NLL(Negative Log Likelihood) 함수이다.

NLL = - sum(log(out_i[c_i]))

sum: N개의 샘플 합

c_i: 샘플 i에 대한 정답 클래스

분류를 위한 손실 계산

순방향 전달 후 마지막 (선형) 계층에서 출력값을 얻는다.
이들의 소프트맥스 값을 계산하여 확률을 얻는다.
(파라미터의 가능도에 해당하는) 정답 클래스와 일치하는 예측 확률값을 얻는다. 지도 (supervised) 문제이기 때문에 실측값이 존재하므로, 정답 클래스를 안다고 가정할 수 있다.
로그값을 계산해서 앞에 마이너스를 붙인 다음 손실갓에 더한다.

파이토치로 처리하는 과정

nn.NLLLoss 클래스를 제공

-> 확률 대신 로그 확률의 텐서를 받는다.

-> 데이터 배치에 대한 모델의 NLL을 계산한다.

입력 형태가 이런 형식인 데에는 나름의 이유가 있다.

입력을 확률의 로그값으로 받으면, 확률이 0에 가까울 경우 문제가 된다.

-> nn.Softmax 대신 nn.LogSoftmax를 사용함으로써 계산이 안정적으로 수행되게 하는

model = nn.Sequential(
            nn.Linear(3072, 512),
            nn.Tanh(),
            nn.Linear(512, 2),
            nn.LogSoftmax(dim=1))
            
loss = nn.NLLLoss() # NLL 손실값 초기화

분류 문제에서는 (MSE보다) 크로스엔트로피 손실을 사용하는 것이 더 좋다.

7.2.6 분류기 훈련

import torch
import torch.nn as nn
import torch.optim as optim

model = nn.Sequential(
            nn.Linear(3072, 512),
            nn.Tanh(),
            nn.Linear(512, 2),
            nn.LogSoftmax(dim=1))

learning_rate = 1e-2

optimizer = optim.SGD(model.parameters(), lr=learning_rate)

loss_fn = nn.NLLLoss()

n_epochs = 100

for epoch in range(n_epochs):
    for img, label in cifar2:
        out = model(img.view(-1).unsqueeze(0))
        loss = loss_fn(out, torch.tensor([label]))
                
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

    print("Epoch: %d, Loss: %f" % (epoch, float(loss)))

결과

Epoch: 0, Loss: 5.347057
Epoch: 1, Loss: 7.705317
Epoch: 2, Loss: 6.510838
Epoch: 3, Loss: 9.557189
Epoch: 4, Loss: 4.151933
Epoch: 5, Loss: 5.636873
Epoch: 6, Loss: 6.531207
Epoch: 7, Loss: 20.450516
Epoch: 8, Loss: 5.072948
Epoch: 9, Loss: 4.941860
Epoch: 10, Loss: 6.445535
Epoch: 11, Loss: 4.580799
Epoch: 12, Loss: 6.660308
Epoch: 13, Loss: 9.436373
Epoch: 14, Loss: 16.786476
Epoch: 15, Loss: 8.349138
Epoch: 16, Loss: 8.176860
Epoch: 17, Loss: 5.862664

단일 샘플에서 부분적으로 기울기를 얻어 파라미터를 변경한다.

그런데 하나의 샘플에 기반해서 손실값을 줄이는 게 다른 샘플에 대해서는 안 좋아진 것일 수 있다.

그래서 각 에포크마다 샘플을 섞은 후 한 번에 하나 혹은 여러 개의 샘플에 대해 기울기를 평가하면 경사 하강에 랜덤한 효과를 줄 수 있다.

SGD의 S는 확률적이라는 의미로서, 섞은 데이터의 작은 배치 단위로 수행한다.

미니 배치에서 얻은 기울기를 사용하면 전체 데이터셋에 대한 값만큼 근사하지는 않지만 훈련 중에 만날지도 모르는 지역 최솟값에 최적화 프로세스가 빠져버리는 것을 예방하고 수렴을 돕는 것으로 알려져 있다.

미니배치에서의 기울기는 이상적인 궤적에서 랜덤하게 떨어져있다.

그래서 이 경우 윌는 작은 학습률을 사용한다.

각 에포크에서 데이터셋을 섞으면 미니 배치에서 얻은 기울기의 시퀀스가 전체 데이터셋에서 계산한 기울기를 대표하도록 만드는데 도움을 된다.

훈련 전에 상수로 고정하는 값들을 모델의 파라미터와 구분하여 하이퍼파라미터라 부른다.

(6장 (2)에서 자세히 살펴봤었다.)

데이터셋에서 한 번에 하나의 아이템을 골라 크기가 1인 미니 배치를 만든다.

torch.utils.data 모듈에는 미니 배치의 데이터를 섞거나 구조화하는 작업을 돕는 DataLoader 클래스가 있다.

데이터 로더를 활용해 데이터셋에서 미니 배치에 포함될 샘플을 가져올 때 여러 가지 샘플링 전략 중에서 하나를 고를 수 있다.

가장 흔한 전략은 각 에포크마다 데이터를 섞은 후 고르게 샘플링하는 것이다.

train_loader = torch.utils.data.DataLoader(cifar2, batch_size=64,
                                           shuffle=True)

※ shuffle은 불리언 값으로, 데이터가 각 에포크마다 섞여야 할지를 결정한다.

DataLoader는 순회 가능하기 때문에 루프 안에 바로 넣어 사용 할 수 있다.

import torch
import torch.nn as nn
import torch.optim as optim

train_loader = torch.utils.data.DataLoader(cifar2, batch_size=64,
                                           shuffle=True)

model = nn.Sequential(
            nn.Linear(3072, 128),
            nn.Tanh(),
            nn.Linear(128, 2),
            nn.LogSoftmax(dim=1))

learning_rate = 1e-2

optimizer = optim.SGD(model.parameters(), lr=learning_rate)

loss_fn = nn.NLLLoss()

n_epochs = 100

for epoch in range(n_epochs):
    for imgs, labels in train_loader:
        outputs = model(imgs.view(imgs.shape[0], -1))
        loss = loss_fn(outputs, labels)

        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

    print("Epoch: %d, Loss: %f" % (epoch, float(loss)))

결과

Epoch: 0, Loss: 0.604063
Epoch: 1, Loss: 0.597974
Epoch: 2, Loss: 0.271415
Epoch: 3, Loss: 0.451056
Epoch: 4, Loss: 0.629758
Epoch: 5, Loss: 0.458762
Epoch: 6, Loss: 0.277813
Epoch: 7, Loss: 0.406921
Epoch: 8, Loss: 0.951961
Epoch: 9, Loss: 0.433738
Epoch: 10, Loss: 0.351960
Epoch: 11, Loss: 0.355687
Epoch: 12, Loss: 0.518611
Epoch: 13, Loss: 0.262623
Epoch: 14, Loss: 0.221969
Epoch: 15, Loss: 0.774132
Epoch: 16, Loss: 0.324406
Epoch: 17, Loss: 0.447701

손실값이 줄어들고 있는 것을 확인 할 수 있다.

확인해보자.

val_loader = torch.utils.data.DataLoader(cifar2_val, batch_size=64,
                                         shuffle=False)

correct = 0
total = 0

with torch.no_grad():
    for imgs, labels in val_loader:
        outputs = model(imgs.view(imgs.shape[0], -1))
        _, predicted = torch.max(outputs, dim=1)
        total += labels.shape[0]
        correct += int((predicted == labels).sum())
        
print("Accuracy: %f" % (correct / total))

결과

Accuracy: 0.821000

모델에 계층을 더 추가하면 모델의 깊이나 용량이 늘어나게 된다.

model = nn.Sequential(
            nn.Linear(3072, 1024),
            nn.Tanh(),
            nn.Linear(1024, 512),
            nn.Tanh(),
            nn.Linear(512, 128),
            nn.Tanh(),
            nn.Linear(128, 2),
            nn.LogSoftmax(dim=1))

nn.NLLLoss는 타깃에 모든 것을 담아 넣는 디랙 분포와 로그 확률 입력으로 주어지는 예측 분포 사이의 크로스엔트로피라고 볼 수 있다.

정보 이론 중 샘플 크기로 정규화하는 부분에서 이 크로스 엔트로피는 타깃의 분포에 대한 예측 분포로서 '음의 로그 가능도'로 해석할 수 있다.

그래서 두 손실값 모두 우리의 모델 확률을 예측한다고 할 때 주어진 데이터에 대한 모델 파라미터의 음의 로그 가능도라 할 수 있다.

model = nn.Sequential(
            nn.Linear(3072, 1024),
            nn.Tanh(),
            nn.Linear(1024, 512),
            nn.Tanh(),
            nn.Linear(512, 128),
            nn.Tanh(),
            nn.Linear(128, 2))

loss_fn = nn.CrossEntropyLoss()

모델의 출력을 확률로 해석 가능하지 못하는 단점이 있다.

그래서 출력을 다시 소프트맥스에 명시적으로 연결할 필요가 있다.

훈련셋에 대한 정확도가 0.9918 이런식으로 나온다면 과적합 되었을 가능성이 높다.

nn.Model의 parameters() 메소드를 통해 모델이 얼마나 많은 파라미터를 가지고 있는지를 빠르게 확인할 수 있다.

numel_list = [p.numel()
              for p in connected_model.parameters()
              if p.requires_grad ==True]
sum(numel_list), numel_list

7.2.7 완전 연결의 한계

완전 신경망은 평행이동 불변성이 없다.

이를 보완하려면 데이터셋을 증강해서, 즉 훈련 때 이미지를 랜덤하게 평행이동시켜서 이미지의 모든 영역에서 스핏파이어를 보게 해야 하고 이 작업을 데이터셋의 모든 이미지에 대해 수행해야 한다.

(하지만 이러한 데이터 증강 전략은 상당한 비용이 든다.

파라미터에 해당하는 은닉된 피처의 수가 이렇게 평행이동시킨 복제본에 대한 모든 정보를 보관하기 충분할 만큼 커야 하기 때문)

[개념] 학습의 종류

김춘식_123 — Fri, 2 Aug 2024 11:49:51 +0900

머신러닝/딥러닝을 공부할 때 필요한 학습의 대표 4가지를 알아봅시다.

지도 학습 (Supervised Learning)

- 입력 데이터와 그에 대응하는 정답(레이블)이 주어졌을 때, 모델이 주어진 입력에 대한 올바른 출력을 예측하도록 학습하는 방법

예를 들어서 그림에 있는 동물을 맞추는 문제라고 한다면,

강아지 그림에는 '강아지'라는 답을, 고양이 그림에는 '고양이'라는 답

즉, 라벨을 붙여주는 것이다. (라벨링이라고 한다.)

답을 알려준다.

종류

1. 분류

- 입력 데이터를 미리 정의된 클래스 레이블 중 하나로 분류

- 입력 값이 '수치형'이거나 '범주형'인 경우 사용

- 보통 새로운 데이터 포인트가 어느 클래스에 속하는지 예측하는 데 사용

- 이미지 분류에 사용되며, CNN / AlexNet / ResNet 과 같은 알고리즘이 있다.

ex) 이미지 분류, 질병 양성(1)/음성(0) 여부

(그래서 대부분 결과가 0이나 1로 딱 떨어진다.)

그래프가 이쁘진 않지만.. 직관적으로 보기 위해 만들었다.

직접 해보고 싶다면 아래 링크에 들어가서 베이스라인 코드에 따라 분류해보는 것을 추천한다.

↓ 난 잘 모르겠다. 머신러닝으로 시도해봐야지 ↓

당뇨병 위험 분류 예측 AI해커톤 - DACON

분석시각화 대회 코드 공유 게시물은 내용 확인 후 좋아요(투표) 가능합니다.

dacon.io

↓ 딥러닝(CNN)으로 즐겨야지 ↓

서울 랜드마크 이미지 분류 AI 해커톤 - DACON

분석시각화 대회 코드 공유 게시물은 내용 확인 후 좋아요(투표) 가능합니다.

dacon.io

2. 회귀

- 입력 데이터를 기반으로 연속적인 값을 예측

- 입력 값이 '수치형'인 경우 사용

- 보통 미래 데이터를 예측하는데 사용

- 시계열 데이터를 분석하는데 사용되며, RNN / LSTM 알고리즘이 있다.

ex) 주식 가격 예측

코드는 아래 참고

(결과는 어느 숫자든 나올 수 있다. 소득 예측이라면 5달러가 나올수도, 243.2321424달러가 나올 수도 있다.)

↓ 아래 대회들을 추천한다 ! ↓

소득 예측 AI 해커톤 - DACON

분석시각화 대회 코드 공유 게시물은 내용 확인 후 좋아요(투표) 가능합니다.

dacon.io

풍속 예측 AI 해커톤 - DACON

분석시각화 대회 코드 공유 게시물은 내용 확인 후 좋아요(투표) 가능합니다.

dacon.io

* 위 대회에 들어가서 데이터를 살펴보는 것만으로도 더 잘 이해할 수 있을 것이다.

비지도 학습 (Unsupervised Learning)

- 입력 데이터에 대한 정답(레이블) 없이 학습하는 방법

- 클러스터링, 차원 축소에 사용되며, 가우시안 혼합 모델 / 자기 조직화 지도 알고리즘이 있다.

종류

● 클러스터링 (Clustering)

- 데이터 포인트를 유사한 특성을 가진 그룹으로 묶는 방법 (군집화)

ex) 고객 세분

*분류와 클러스터링가 비슷하게 느껴질 수 있는데 목적 자체가 다르다.

분류는 새로운 데이터가 들어왔을 때 올바른 클래스에 '할당(분류)'하기 위한 것이고,

클러스터링은 데이터의 특징을 '발견'하기 위한 것이다.

전이 학습 (transfer learning)

- 한 작업에 대해 사전 학습된 모델을 새로운 관련 작업에 맞게 미세 조정하는 기법

- 새로운 모델을 만드는 것은 시간이 많이 필요하므로, 전이학습을 사용하여 새 데이터가 포함된 관련 작업에 대해 기존 모델을 재교육

- 데이터가 부족할 때 매우 유용하다.

- 음성 및 오디오 처리, 텍스트 분석, 컴퓨터 비전 등 다양한 분야에서 사용되며, VGG16 과 같은 알고리즘이 있다.

Transfer Learning - MATLAB & Simulink (mathworks.com)

강화 학습 (Reinforcement Learning)

- 에이전트(결정을 내리고 행동을 수행하는 주체) 가 환경과 상호작용하면서 보상을 최대화하는 방향으로 행동을 학습하는 기법

- 지도학습이나 비지도학습과는 달리, 정답을 직접 제공받지 않고 시도와 실패를 통해 학습

- 로보틱스와 자율주행에서 많이 사용되고 있다.

아주 쉽게 생각하려면 게임을 생각하면 된다.

게임을 할때 캐릭터가 죽으면 게임오버가 뜨며 사람을 학습한다.

그럼 다음에는 죽은 원인을 피해 갈 것이다.

반대로 행동을 해 아이템을 얻으면 다음에도 같은 행동을 할 것이다.

이러한 방법과 똑같이 컴퓨터가 정답이 없는 문제를 해결해가는 것이다.

에이전트가 행동에 대한 보상으로 학습하는 것으로 요약할 수 있다.

강화학습이란? - MATLAB & Simulink (mathworks.com)

아래는 머신러닝 3대장 사진으로 참고하면 좋을 것 같다.

강화학습이란? - MATLAB & Simulink (mathworks.com)

[파이토치 딥러닝 마스터] 7장 (1)

김춘식_123 — Thu, 1 Aug 2024 11:49:58 +0900

Github 참조

onlybooks/pytorch: 파이토치 딥러닝 마스터 (github.com)

GitHub - onlybooks/pytorch: 파이토치 딥러닝 마스터

파이토치 딥러닝 마스터. Contribute to onlybooks/pytorch development by creating an account on GitHub.

github.com

개인 공부 할 때 적은 것으로, 코드 위주로 설명됩니다. (추후 내용 추가 될 수 있음)

7장 내용을 다루고 있습니다.

7.1 작은 이미지를 모아놓은 데이터

7.1.1 CIFAR-10 다운로드

from torchvision import datasets
data_path = '../data-unversioned/p1ch7/'
cifar10 = datasets.CIFAR10(data_path, train=True, download=True) 
# 훈련 데이터용 데이터 객체를 만든다. 데이터가 없으면 토치 비전이 알아서 다운로드한다.
cifar10_val = datasets.CIFAR10(data_path, train=False, download=True) 
# train=False 설정으로 검증용 데이터를 얻을 수 있으며, 필요시 내려받게 된다.

imshow로 사진 확인해보는 코드

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

fig = plt.figure(figsize=(8,3))
num_classes = 10
for i in range(num_classes):
    ax = fig.add_subplot(2, 5, 1 + i, xticks=[], yticks=[])
    ax.set_title(class_names[i])
    img = next(img for img, label in cifar10 if label == i)
    plt.imshow(img)
plt.show()

결과

7.1.2 데이터셋 클래스

len(cifar10)

결과

50000

데이터셋에 __getitem__ 메소드가 구현되어 있으므로 개별 아이템에 접근할 때 표준 서브스크립트에 해당하는 색인용 튜플과 리스트를 사용할 수 있다.

다음 코드는 '자동차'에 해당하는 정수값이 1인 PIL 형식의 이미지를 얻는 코드이다.

img, label = cifar10[99]
img, label, class_names[label]

결과

(<PIL.Image.Image image mode=RGB size=32x32 at 0x7FB383657390>,
1,
'automobile')

data.CIFAR10 데이터셋 샘플은 RGB PIL 이미지 객체라서 바로 그려볼 수 있다.

plt.imshow(img)
plt.show()

결과

7.1.3 데이터 변환

PIL 이미지를 파이토치 텐서로 변환할 단계다.

torchvision.transforms가 필요하다.

이 모듈은 재구성 가능한 함수 형태의 여러 객체를 정의하고 있어서 datasets.CIFAR10 같은 torchvistion 데이터셋에 인자로 전달할 수 있고 로드한 다음에 __getitem__가 결과를 반환하기에 앞서 변환을 수행한다.

+)transforms는 pytorch에서 사용할 수 있다.

Transforming and augmenting images — Torchvision 0.19 documentation (pytorch.org)

Transforming and augmenting images — Torchvision 0.19 documentation

Shortcuts

pytorch.org

위 링크에서 관련 함수를 찾아보는 걸 추천한다.

아래는 사용 가능한 개체이다.

from torchvision import transforms
dir(transforms)

결과

['CenterCrop',
'CenterCropVideo',
'ColorJitter',
'Compose',
'FiveCrop',
'Grayscale',
'Lambda',
'LinearTransformation',
'Normalize',
'NormalizeVideo',
'Pad',
'RandomAffine',
'RandomApply',
'RandomChoice',
'RandomCrop',
'RandomCropVideo',
'RandomErasing',
'RandomGrayscale',
'RandomHorizontalFlip',
'RandomHorizontalFlipVideo',
'RandomOrder',
'RandomPerspective',
'RandomResizedCrop',
'RandomResizedCropVideo',
'RandomRotation',
'RandomSizedCrop',
'RandomVerticalFlip',
'Resize',
'Scale',
'TenCrop',
'ToPILImage',
'ToTensor',
'ToTensorVideo',
'__builtins__',
'__cached__',
'__doc__',
'__file__',
'__loader__',
'__name__',
'__package__',
'__path__',
'__spec__',
'functional',
'functional_video',
'transforms',
'transforms_video']

이 중에 ToTensor라는 게 있는데 넘파이 배열과 PIL 이미지를 텐서로 바꾸는 역할을 한다.

뿐만 아니라 출력 텐서의 차원 레이아웃을 C X H X W 로 맞춰준다.

ToTensor 변환을 사용해보자. 객체로 만들면 PIL 이미지를 인자로 함수처럼 호출할 수 있고 텐서를 리턴한다.

from torchvision import transforms

to_tensor = transforms.ToTensor()
img_t = to_tensor(img)
img_t.shape

결과

torch.Size([3, 32, 32])

이미지가 3 X 32 X 32 텐서로 바뀌었고 이제 RGB 세 개의 채널을 가지는 32 X 32 이미지가 됐다.

label 값은 변동 없이 정수값을 그대로 가진다.

변환 자체를 dataset.CIFAR10의 인자로 전달하는 것도 가능하다.

7.1.4 데이터 정규화

변환 기능은 매우 유용한데 특히 transforms.Compose로 여러 변환을 엮어서 사용할 때 더욱 그렇다.

잘 사용하면 정규화 데이터 증강(augmentation) 도 데이터 로딩과 함께 수행할 수 있다.

코드에 들어가기 전에 데이터 증강에 대해서 살펴보면 좋을 것 같다.

데이터 증강은 말 그대로 훈련 데이터의 양을 증가시키고 모델의 일반화 성능을 높이기 위해 사용한다.

일반적인 데이터 증강 기법으로는 회전, 이동, 확대, 축소, 뒤집기, 잘라내기, 색상 변형 등이 있다.

우리집 토리 사진이다. 뒤집기, 반전, 흐리게하는 효과를 사용했다.

이런식으로 원본이 하나 있을 때 여러 기법을 사용해 데이터를 증강시키는 것이다.

데이터셋 정규화로 각 채널이 평균값 0과 단위 표준편차를 가지게 만드는 연습을 하자.

왜 필요할까?

1. -1과 1 혹은 -2와 2 사이에서 선형인 활성 함수를 택하고 데이터를 같은 범위에서 평균을 가지게 한다면 뉴런은 0이 아닌 기울기를 가지게 되므로 빨리 학습할 수 있기 때문이다.

2. 각 채널을 정규화해 동일한 분산을 가지게 한다면 채널 정보가 동일한 학습률로 경사 하강을 통해 섞이고 업데이트되는 것도 보장할 수 있다.

imgs = torch.stack([img_t for img_t, _ in tensor_cifar10], dim=3)
imgs.shape

결과

torch.Size([3, 32, 32, 50000])

이제 채널별로 평균을 쉽게 계산할 수 있다.

imgs.view(3, -1).mean(dim=1) 
# view(3, -1)은 세 채널은 유지하고 나머지 차원을 적절한 크기 하나로 합친다.
# 그래서 3 x 32 x 32 이미지는 3 x 1024 벡터로 바뀌고 평균은 각 채널의 1024개 요소에 대해 계산하는 것이다.

결과

tensor([0.4915, 0.4823, 0.4468])

표준편차 계산

imgs.view(3, -1).std(dim=1)

결과

tensor([0.2470, 0.2435, 0.2616])

이제 Normalize 변환을 초기화할 수 있다.

transforms.Normalize((0.4915, 0.4823, 0.4468), (0.2470, 0.2435, 0.2616))

결과

Normalize(mean=(0.4915, 0.4823, 0.4468), std=(0.247, 0.2435, 0.2616))

그리고 ToTensor 변환에 이어 붙인다.

transformed_cifar10 = datasets.CIFAR10(
    data_path, train=True, download=False,
    transform=transforms.Compose([
        transforms.ToTensor(),
        transforms.Normalize((0.4915, 0.4823, 0.4468),
                             (0.2470, 0.2435, 0.2616))
    ]))

데이터를 그려 확인해보면 많이 달라진 것을 확인 할 수 있다.

img_t, _ = transformed_cifar10[99]

plt.imshow(img_t.permute(1, 2, 0))
plt.show()

결과

정규화되어버린 빨간 자동차 사진 ~

아래는 원래 데이터이다.

7.2 새와 비행기를 구별하기

프레임 안에 뭔가가 들어오면 찍어서 바로 클럽의 실시간 탐조 블로그에 업로드하는 카메라가 있다.

조류 사진을 찍고 싶은데 날아다니는 비행기도 찍히는 문제가 발생한다.

이를 해결하기 위해, 데이터셋에서 새와 비행기를 골라낸 후 신경망을 만들어 새와 비행기를 구분해보자.

7.2.1 데이터셋 구축

가장 먼저 할 일: 데이터의 차원 정보를 맞추는 일

새와 비행기만 들어간 Dataset 서브 클래스를 만든다.

(데이터셋이 작으며, 인덱싱과 len만 있으면 되기 때문에 굳이 torch.utils.data.dataset.Dataset의 서브클래스일 필요는 없다.)

label_map = {0: 0, 2: 1}
class_names = ['airplane', 'bird']
cifar2 = [(img, label_map[label])
          for img, label in cifar10 
          if label in [0, 2]]
cifar2_val = [(img, label_map[label])
              for img, label in cifar10_val
              if label in [0, 2]]

cifar2 객체는 Dataset의 기본 요구사항을 만족한다.

즉 __len__과 __getitem__이 정의되어 있다.

7.2.2 완전 연결 모델

신경망은 피처(feature) 텐서가 들어가고 피처 텐서가 나오는 것이다.

이미지도 결국 공간 설정에 따라 적절히 배치된 숫자 집합일 뿐이다.

import torch.nn as nn

n_out = 2

model = nn.Sequential(
            nn.Linear(
                3072,  # 입력피처
                512,   # 은닉층 크기
            ),
            nn.Tanh(),
            nn.Linear(
                512,   # 은닉층 크기
                n_out, # 출력 클래스
            )
        )

임의로 512개의 은닉된 피처를 골랐다.

신경망은 최소 하나 이상의 비선형성을 가진 은닉층(활성 함수를 포함하므로 두 개의 모듈) 이 필요하다.

(임의의 함수를 학습할 수 있어야 하기 때문, 그렇지 않으면 단순 선형 모델에 불과할 뿐이다.)

은닉된 피처는 가중치 행렬로 인코딩된 입력값들 간의 (학습된) 관계를 나타낸다.

7.2.3 분류기의 출력

신경망이 단일한 스칼라값(n_out = 1)을 출력하게 마들고 레이블을 부동소숫점 수로 변환한 후(비행기는 0.0으로 새는 1.0으로) 이를 MSELoss(배치상에서 실측값과의 차이를 제곱한 값의 평균)의 타깃으로 사용한다.

-> 이렇게 이 문제를 회귀 문제로 만든다.

-> 하지만 조금 다름을 알 수 있는데, 출력값이 카테고리라는 것을 인식할 필요가 있다.

출력값이 새, 비행기 밖에 없다.

카테고리 변수를 표현할 때는 [1,0]을 비행기로, [0,1]을 새로 하는 것처럼 원핫 인코딩으로 바꿔줘야 한다. (순서는 상관없다.)

이상적인 경우 신경망은 비행기에 대해 torch.tensor([1.0, 0.0])을 출력하고 새에 대해 torch.tensor([0.0, 1.0])을 출력한다.

실제로 우리 분류기는 완벽하지 않으므로 신경망의 출력은 두 값 사이가 될 것이다.

중요한 포인트는 출력을 확률로 해석할 수 있다는 점이다.

첫 번째 값은 '비행기'일 확률이고, 두 번째 값은 '새'일 확률이다.

문제를 확률로 보게 되면 신경망의 출력에 추가적인 제약을 수반한다.

출력값의 요소가 가질 수 있는 값은 [0.0, 1.0] 범위로 제한된다.
모든 출력 오소의 값의 합은 1.0이다.

7.2.4 출력을 확률로 표현하기

소프트맥스는 벡터값을 받아 동일한 차원의 다른 벡터를 만드는데, 값이 확률로 표현되어야 하는 제약을 만족한다

벡터의 각 요소 단위로 지수 연산 후 각 요소를 지수 값의 총합으로 나눈다.

def softmax(x):
    return torch.exp(x) / torch.exp(x).sum()

입력 벡터로 테스트 해보자.

x = torch.tensor([1.0, 2.0, 3.0])

softmax(x)

결과

tensor([0.0900, 0.2447, 0.6652])

확률 제한사항을 만족한다.

softmax(x).sum()

결과

tensor(1.)

소프트맥스는 단조함수라서 입력값이 낮아지면 출력값도 따라서 낮아진다.

하지만 범위까지 맞춰주지는 않아서 각 값들 간의 비율이 유지되지 않는다.

(실제로는 모델 파라미터가 학습 과정을 통해 값이 적당한 비율로 맞춰지도록 정해지므로 큰 문제가 되지 않는다.)

softmax = nn.Softmax(dim=1)

x = torch.tensor([[1.0, 2.0, 3.0],
                  [1.0, 2.0, 3.0]])

softmax(x)

결과

tensor([[0.0900, 0.2447, 0.6652],
[0.0900, 0.2447, 0.6652]])

배치를 다뤘던 때처럼 두 행에 두 개의 입력 벡터가 있다.

그래서 차원 1을 따라 nn.softmax가 동작하도록 초기화했다.

model = nn.Sequential(
            nn.Linear(3072, 512),
            nn.Tanh(),
            nn.Linear(512, 2),
            nn.Softmax(dim=1))

img, _ = cifar2[0]

plt.imshow(img.permute(1, 2, 0))
plt.show()

결과

※ 모델을 호출하려면 먼저 입력 차원이 맞아야 한다.

img_batch = img.view(-1).unsqueeze(0)

모델을 호출할 준비가 되었다.

out = model(img_batch)
out

결과

tensor([[0.4784, 0.5216]], grad_fn=<SoftmaxBackward>)

_, index = torch.max(out, dim=1)

index

결과

tensor([1])

이미지가 '새'라고 식별됐다.

[파이토치 딥러닝 마스터] 6장 (2)

김춘식_123 — Wed, 31 Jul 2024 15:36:49 +0900

Github 참조

onlybooks/pytorch: 파이토치 딥러닝 마스터 (github.com)

GitHub - onlybooks/pytorch: 파이토치 딥러닝 마스터

파이토치 딥러닝 마스터. Contribute to onlybooks/pytorch development by creating an account on GitHub.

github.com

개인 공부 할 때 적은 것으로, 코드 위주로 설명됩니다. (추후 내용 추가 될 수 있음, 1차 수정 07.31 )

6장 내용을 다루고 있습니다.

6.3 드디어 신경망

신경망은 인간의 두뇌에서 영감을 얻은 방식으로 데이터를 처리하도록 컴퓨터를 가르치는 인공 지능 방식으로,

input layer, hidden layer, output layer로 이루어져있다.

출처: 신경망이란 무엇인가요? - 인공 신경망 설명 - AWS (amazon.com)

입력 계층

외부 세계의 정보는 입력 계층에서 인공 신경망으로 들어갑니다. 입력 노드는 데이터를 처리하여 분석 또는 분류한 후 다음 계층으로 전달합니다.

숨겨진 계층

숨겨진 계층은 입력 계층이나 다른 숨겨진 계층에서 입력을 받습니다. 인공 신경망에는 많은 수의 숨겨진 계층이 있을 수 있습니다. 각 숨겨진 계층은 이전 계층의 출력을 분석해서 추가 처리하여 다음 계층으로 전달합니다.

출력 계층

출력 계층은 인공 신경망이 처리하는 모든 데이터의 최종 결과를 제공합니다. 단일 또는 다중 노드를 가질 수 있습니다. 예를 들어 이진(예/아니오) 분류 문제가 있는 경우 출력 계층에는 하나의 출력 노드가 있으며 결과는 1 또는 0입니다. 그러나 다중 클래스 분류 문제가 있는 경우 출력 계층은 둘 이상의 출력 노드로 구성될 수 있습니다.

6.3.1 선형 모델 대체하기

nn은 nn.Sequential 컨테이너를 통해 모듈을 간단하게 결합시켜준다.

seq_model = nn.Sequential(
            nn.Linear(1, 13), # <1>
            nn.Tanh(),
            nn.Linear(13, 1)) # <2>
seq_model

결과

Sequential(
  (0): Linear(in_features=1, out_features=13, bias=True)
  (1): Tanh()
  (2): Linear(in_features=13, out_features=1, bias=True)
)

결과적으로 모델을 얻게 되며, 모델의 첫 번째 모듈은 nn.Sequential의 첫 번째 인자에 해당한다.

이 모듈의 중간 출력은 이어지는 다른 모듈에 전달되며 최종적으로 마지막 모듈에 의해 출력이 만들어진다.

6.3.2 파라미터 살펴보기

5장에서 부터 파라미터에 대한 내용이 반복되는데 이제는 자세히 집고 넘어가자.

파라미터는 매개변수로 모델이 데이터를 통해 학습하는 변수를 말한다.

선형 회귀 모델 y = ax + b 이라면 파라미터는 a와 b가 된다.

더 나아가, 신경망의 학습을 통해서 찾아가는 파라미터를 가중치(weights, bias)라고 하는 것이다.

5장 내용을 충분히 이해했다면 바로 무슨 말인지 알아들을 것이다. 이해가 안된다면 5장(1)을 다시 공부해야 한다.

하이퍼파라미터에 대한 개념도 중요해질 것 같은데,

미리 간단하게 설명하자면 모델 학습 과정에서 사전에 설정하는 변수들로, 직접 학습되지 않으며, 모델의 학습 과정을 제어한다.

모델 내부에서 정해지는 파라미터와 달리 사람이 설정하는데, 우리가 아는 하이퍼파라미터의 대표적인 예로 epoch나 learning rate등이 있다.

(책에서 하이퍼파라미터 개념 자체는 7장(2)에 나오니 참고하라)

책 내용으로 돌아가보자.

model.parameter()를 호출하면 첫 번째와 두 번째 선형 모듈에서 weight와 bias를 모은다.

파라미터를 살펴보기 위해 차원 정보를 출력하는 게 좋다.

[param.shape for param in seq_model.parameters()]

결과

[torch.Size([13, 1]), torch.Size([13]), torch.Size([1, 13]), torch.Size([1])]

이 텐서가 최적화 함수로 전달될 텐서다.

이제 model.backward()를 호출하면, grad에서 파라미터가 추출되고 옵티마이저는 optimizer.step() 호출 과정에서 적절하게 파라미터 값을 조정한다.

nn.Modules의 파라미터에 대해 좀 더 알아보자.

여러 개의 서브 모듈로 만들어진 모델의 파라미터를 추적할 경우, 파라미터를 이름으로 식별하게 하면 매우 편리하다.

이를 위해 named_parameters 메소드가 존재한다.

for name, param in seq_model.named_parameters():
    print(name, param.shape)

결과

0.weight torch.Size([13, 1])
0.bias torch.Size([13])
2.weight torch.Size([1, 13])
2.bias torch.Size([1])

Sequential의 각 모듈 이름은 인자에서 모듈이 나타난 순서를 따른다.

Sequential은 OrderDict라는 인자도 받는데, 여기에 각 모듈의 이름을 정해서 전달해도 된다.

from collections import OrderedDict

seq_model = nn.Sequential(OrderedDict([
    ('hidden_linear', nn.Linear(1, 8)),
    ('hidden_activation', nn.Tanh()),
    ('output_linear', nn.Linear(8, 1))
]))

seq_model

결과

Sequential(
  (hidden_linear): Linear(in_features=1, out_features=8, bias=True)
  (hidden_activation): Tanh()
  (output_linear): Linear(in_features=8, out_features=1, bias=True)
)

이렇게 이름을 붙이면 서브모듈을 더 쉽게 설명할 수 있다.

for name, param in seq_model.named_parameters():
    print(name, param.shape)

결과

hidden_linear.weight torch.Size([8, 1])
hidden_linear.bias torch.Size([8])
output_linear.weight torch.Size([1, 8])
output_linear.bias torch.Size([1])

우리의 신경망이 만든 경로는 순수하게 연속적인 경로를 만들어 내는데 이런 점에서 nn.Sequential이라는 이름은 매우 적절하다.

서브 모듈을 속성처럼 사용해 특정 Parameter에 접근할 수도 있다.

seq_model.output_linear.bias

결과

Parameter containing:
tensor([-0.0173], requires_grad=True)

파라미터를 추적하거나 기울기를 파악하기에 유용한 방법이다.

ex) 훈련시키는 동안 기울기를 모니터링하는 경우 유용

은닉층의 선형 영역에서 weight의 기울기를 출력하고 싶다고 가정하자.

이럴 때에는 새로운 신경망 모델을 위한 훈련 루프를 돌리고 마지막 에포크 후에 만들어진 기울기를 보면 된다.

optimizer = optim.SGD(seq_model.parameters(), lr=1e-3) # <1>

training_loop(
    n_epochs = 5000, 
    optimizer = optimizer,
    model = seq_model,
    loss_fn = nn.MSELoss(),
    t_u_train = t_un_train,
    t_u_val = t_un_val, 
    t_c_train = t_c_train,
    t_c_val = t_c_val)
    
print('output', seq_model(t_un_val))
print('answer', t_c_val)
print('hidden', seq_model.hidden_linear.weight.grad)

결과

Epoch 1, Training loss 182.9724, Validation loss 231.8708
Epoch 1000, Training loss 6.6642, Validation loss 3.7330
Epoch 2000, Training loss 5.1502, Validation loss 0.1406
Epoch 3000, Training loss 2.9653, Validation loss 1.0005
Epoch 4000, Training loss 2.2839, Validation loss 1.6580
Epoch 5000, Training loss 2.1141, Validation loss 2.0215
output tensor([[-1.9930],
        [20.8729]], grad_fn=<AddmmBackward>)
answer tensor([[-4.],
        [21.]])
hidden tensor([[ 0.0272],
        [ 0.0139],
        [ 0.1692],
        [ 0.1735],
        [-0.1697],
        [ 0.1455],
        [-0.0136],
        [-0.0554]])

6.3.3 선형 모델과 비교하기

from matplotlib import pyplot as plt

t_range = torch.arange(20., 90.).unsqueeze(1)

fig = plt.figure(dpi=600)
plt.xlabel("Fahrenheit")
plt.ylabel("Celsius")
plt.plot(t_u.numpy(), t_c.numpy(), 'o')
plt.plot(t_range.numpy(), seq_model(0.1 * t_range).detach().numpy(), 'c-')
plt.plot(t_u.numpy(), seq_model(0.1 * t_u).detach().numpy(), 'kx')

결과

신경망이 노이즈까지 포함해서 측정값을 과도하게 따라가는 과적합 성향을 보임을 알 수 있다.

작디 작은 신경망임에도 측정값이 얼마 되지 않기 때문에 상대적으로 적합에 필요한 양보다 많은 파라미터를 가지고 있는 셈이지만 결과적으로 나쁘지는 않다.

코딩 공부하는 춘식이

PINN 공부 (1)

PINN (Physics - Informed Neural Network)

1. data-driven

2. blackbox

deepxde를 사용한 코드

PYTORCH 로 변환

파이토치란?

파이토치란?

사용 대상

파이토치 특징

파이토치의 장점

파이토치 모듈

파이토치 아키텍처(구조)

파이토치 API

파이토치 엔진

연산처리

텐서플로우와 차이점

파이토치 패키지

[파이썬 기초] 클래스(Class)

클래스(Class)란?

클래스를 사용하는 법

__init__?

self ?

show ?

상속 ?

Super ?

[파이토치 딥러닝 마스터] 8장 (3)

8.5 모델 설계

8.5.1 메모리 용량 늘리기: 너비

8.5.2 모델이 수렴하고 일반화하도록 돕는 방법: 정규화

8.5.3 더 복잡한 구조를 배우기 위해 깊이 파헤치기: 깊이

[파이토치 딥러닝 마스터] 8장 (2)

8.3 nn.Module 서브클래싱하기

8.3.1 nn.Module로 정의된 우리의 신경망

8.3.2 파이토치가 파라미터와 서브모듈을 유지하는 방법

8.3.3 함수형 API

8.4 우리가 만든 컨볼루션 신경망 훈련시키기

8.4.1 정확도 측정

8.4.2 모델을 저장하고 불러오기

8.4.3 GPU에서 훈련시키기

[파이토치 딥러닝 마스터] 8장 (1)

8.1 컨볼루션

8.1.1 컨볼루션의 역할

8.2 컨볼루션 사용해보기

8.2.1 경계 패딩하기

8.2.2 컨볼루션으로 피처 찾아내기

8.2.3 깊이와 풀링으로 한 단계 더 인식하기

8.2.4 우리의 신경망에 적용하기

[파이토치 딥러닝 마스터] 7장 (2)

7.2.5 분류를 위한 손실값

7.2.6 분류기 훈련

7.2.7 완전 연결의 한계

[개념] 학습의 종류

지도 학습 (Supervised Learning)

종류

비지도 학습 (Unsupervised Learning)

종류

전이 학습 (transfer learning)

강화 학습 (Reinforcement Learning)

[파이토치 딥러닝 마스터] 7장 (1)

7.1 작은 이미지를 모아놓은 데이터

7.1.1 CIFAR-10 다운로드

7.1.2 데이터셋 클래스

7.1.3 데이터 변환

7.1.4 데이터 정규화

7.2 새와 비행기를 구별하기

7.2.1 데이터셋 구축

7.2.2 완전 연결 모델

7.2.3 분류기의 출력

7.2.4 출력을 확률로 표현하기

[파이토치 딥러닝 마스터] 6장 (2)

6.3 드디어 신경망

6.3.1 선형 모델 대체하기

6.3.2 파라미터 살펴보기

6.3.3 선형 모델과 비교하기

init?