torch.nn 클래스와 신경망모형

내용

layer building
비선형과 다중 모델

layer building

선형모델의 layer는 nn.Linear 클래스를 사용하여 구축합니다.

nn.Linear에 대한 생성자는 입력 특성의 수(feature #), 출력의 수(label #), 선형 모델에 편향이 포함되는지 여부(여기서 기본값은 True)의 세 가지 인수를 허용합니다.

nn.Linear(input_size, output_size, bias=True): True는 default

import numpy as np
import torch
import torch.nn as nn

x=torch.rand((3, 1))
x

tensor([[0.9445],
            [0.1129],
            [0.4799]])

model=nn.Linear(1,1)
model(x)

tensor([[0.2996],
            [0.5595],
            [0.4448]], grad_fn=< AddmmBackward >)

위 코드는 torch.nn 클래스 객체(model)를 생성한 것입니다. 그 모델의 인수로서 입력인자 x를 전달한 과정입니다. 신경망에서 순전파(forward)과정입니다. 일반적으로 클래스는 model.forward(x)와 같이 그 클래스의 메서드를 호출한 후 사용합니다. 그러나 위의 경우는 메소드의 호출 과정이 생략되었습니다. 오히려 메소드의 호출은 에러를 발생합니다.

y=model.forard(x) : Error 발생
y=model(x) : Right

이것은 nn 클래스에 포함된 __call__ 특벌메소드에 기인합니다. 이 메소드는 지정된 클래스 객체를 자동으로 호출하게합니다.

생성된 모델의 매개변수(들)은 model.parameters() 클래스를 사용하여 호출할 수 있습니다. 또는 가중치와 편차를 각각 wight, bias 속성을 사용하여 확인할 수 있습니다.

model.weight, model.bias

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

임의의 값들에 대한 layer를 구축해 봅니다.

torch.manual_seed(0)
t_c = torch.rand(11)
t_u = torch.rand(11)
t_c=torch.tensor(t_c).unsqueeze(1)
t_u=torch.tensor(t_u).unsqueeze(1)
t_u.shape

torch.Size([11, 1])

model=nn.Linear(1,1)
model(t_u)

 tensor([[0.6656],
            [0.7437],
            [0.7136],
            [0.6878],
            [0.6416],
            [0.6047],
            [0.5837],
            [0.7152],
            [0.6902],
            [0.6080],
            [0.5600]], grad_fn=< AddmmBackward >)

list(model.parameters())

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

비용함수, 최적화

비용함수와 최적화를 다음과 같이 구성하였습니다.

비용함수: nn.MSELoss()
최적화: optim.SGD()

전체 신경망 모형의 실행을 위해 다음 순서로 함수를 작성하였습니다.

model(input) )
loss function (nn.MSELoss())
최적화 초기화(opt.zero_grad()): 최적화를 위해서 특성에 대해 가중치와 편차의 미분을 실시하고 모든 과정이 최적의 매개변수를 발견하기 위해 반복됩니다. 그러나 동일한 변수에 대한 미분의 결과는 계속 축적됩니다. 그러므로 epoch 시작에 이전의 결과를 초기화할 필요가 있습니다.
역전파(loss.backward())
미분의 결과를 사용하여 새로운 매개변수를 계산합니다. 이 계산은 opt.step()함수를 사용합니다.

optimizer=torch.optim.SGD(model.parameters(), lr=1e-2)

def training_loop(epochsN, optimizer, model, lossF, xtr, ytr, printN):
    for epoch in range(1, epochsN+1):
        ptr=model(xtr)
        loss=lossF(ptr, ytr)
        
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
        
        if epoch==1 or epoch%printN==0:
            print(f'Epoch {epoch}, training loss {loss.item():.4f}')

model=nn.Linear(1, 1)
optim=torch.optim.SGD(model.parameters(), lr=1e-1)
training_loop(100, optim, model, nn.MSELoss(), t_c, t_u)

Epoch 1, training loss 0.2543
    Epoch 10, training loss 0.0791
    Epoch 20, training loss 0.0779
    Epoch 30, training loss 0.0778
    Epoch 40, training loss 0.0777
    Epoch 50, training loss 0.0777
    Epoch 60, training loss 0.0776
    Epoch 70, training loss 0.0776
    Epoch 80, training loss 0.0775
    Epoch 90, training loss 0.0775
    Epoch 100, training loss 0.0775

model.weight

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

model.bias

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

비선형과 다중 모델

선형 모델을 비선형 함수로 신경망으로 바꾸어 봅니다. 위 과정에서 모델 layers만 재정의 할 것입니다. 위에서 단순히 선형모델만을 적용했지만 활성화 층을 첨가할 것입니다. 또한 입력 층과 출력층 사이에 여러개의 층을 첨가할 것입니다. 이것은 모델의 용량(capasity) 증가시킵니다.

input:1 dim → Linear:13 dim → Tanh(Activation Function) → Linear: 1 dim → output:1 dim

seqModel=nn.Sequential(nn.Linear(1,13), nn.Tanh(), nn.Linear(13, 1))
seqModel

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

위와 같이 3개의 계층으로 구성된 모형 즉 입력층 → hidden layer(두번째 층) → 출력층인 모형에서 각 계층에서의 매개변수(가중치와 편차)는 모델.parameters() 메서드로 확인할 수 있습니다. 또한 다음과 같이 모델.named_parameters()의 메소드를 사용할 수 있습니다.

for i, j in seqModel.named_parameters():
    print(i, j)

0.weight Parameter containing:
    tensor([[ 0.0382],
            [ 0.2317],
            [ 0.6204],
            [ 0.9602],
            [-0.7706],
            [-0.3665],
            [ 0.3930],
            [ 0.8285],
            [ 0.8702],
            [ 0.8824],
            [ 0.1990],
            [-0.8696],
            [ 0.0920]], requires_grad=True)
    0.bias Parameter containing:
    tensor([-0.6256, -0.9320,  0.8885,  0.7604, -0.9975,  0.1872, -0.1685, -0.1646,
            -0.4578,  0.3846, -0.5923,  0.3666,  0.5057], requires_grad=True)
    2.weight Parameter containing:
    tensor([[ 0.1985,  0.1037, -0.2745, -0.1799,  0.1385,  0.0580, -0.2164, -0.1597,
              0.2609,  0.1869, -0.1209, -0.0698, -0.2642]], requires_grad=True)
    2.bias Parameter containing:
    tensor([-0.0050], requires_grad=True)

list(seqModel.parameters())

[Parameter containing:
     tensor([[ 0.0382],
             [ 0.2317],
             [ 0.6204],
             [ 0.9602],
             [-0.7706],
             [-0.3665],
             [ 0.3930],
             [ 0.8285],
             [ 0.8702],
             [ 0.8824],
             [ 0.1990],
             [-0.8696],
             [ 0.0920]], requires_grad=True),
     Parameter containing:
     tensor([-0.6256, -0.9320,  0.8885,  0.7604, -0.9975,  0.1872, -0.1685, -0.1646,
             -0.4578,  0.3846, -0.5923,  0.3666,  0.5057], requires_grad=True),
     Parameter containing:
     tensor([[ 0.1985,  0.1037, -0.2745, -0.1799,  0.1385,  0.0580, -0.2164, -0.1597,
               0.2609,  0.1869, -0.1209, -0.0698, -0.2642]], requires_grad=True),
     Parameter containing:
     tensor([-0.0050], requires_grad=True)]

state_dict() 매소드를 사용하여 각 매개변수를 호출할 수 있습니다. 이 매서드는 각 계층의 매개변수(가중치와 편향)을 사전형식으로 전환한 객체를 생성합니다.

seqModel.state_dict().keys()

 odict_keys(['0.weight', '0.bias', '2.weight', '2.bias'])

for i, j in seqModel.state_dict().items():
    print(i, j.shape)

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

최종 매개변수를 확인해봅니다.

seqModel.state_dict()['2.weight']

tensor([[ 0.1985,  0.1037, -0.2745, -0.1799,  0.1385,  0.0580, -0.2164, -0.1597,
              0.2609,  0.1869, -0.1209, -0.0698, -0.2642]])

임의의 값(feature x, label y)에 대한 신경망 모형을 구축합니다.

x=torch.tensor([0.5, 14.0, 15.0, 28.0, 11.0, 8.0, 3.0, -4.0, 6.0, 13.0, 21.0]).reshape(-1,1)
y=torch.tensor([35.7, 55.9, 58.2, 81.9, 56.3, 48.9, 33.9, 21.8, 48.4, 60.4, 68.4]).reshape(-1,1)
x

tensor([[ 0.5000],
            [14.0000],
            [15.0000],
            [28.0000],
            [11.0000],
            [ 8.0000],
            [ 3.0000],
            [-4.0000],
            [ 6.0000],
            [13.0000],
            [21.0000]])

이 모형에서 최초 층의 입력과 출력은 각각 1, 13입니다. 다음 층은 비선형으로 만들기 위한 것으로 차원은 첫번째 층과 같으며 최종 층은 1개의 출력으로 구성됩니다. 이에 부합한 가중치와 평균은 13개입니다. 그러므로 최종 출력은 다음과 같이 계산됩니다.

$$\begin{bmatrix} x_{1,1}&\cdots &x_{1, 13}\end{bmatrix} \begin{bmatrix}w_{1,1}\\\vdots \\w_{1,13}\end{bmatrix}+b_1$$

최적화를 정의하고 위에서 생성한 모델 학습 함수(training_loop)에 의해 모델을 학습합니다.

seqModel=nn.Sequential(nn.Linear(1,13), nn.Tanh(), nn.Linear(13, 1))
optim=torch.optim.SGD(seqModel.parameters(),lr=1e-3)
training_loop(epochsN=1000, optimizer=optim, model=seqModel, lossF=nn.MSELoss(), xtr=x, ytr=y, printN=100)

Epoch 1, training loss 2953.2764
    Epoch 100, training loss 160.1665
    Epoch 200, training loss 74.2037
    Epoch 300, training loss 49.7618
    Epoch 400, training loss 65.7139
    Epoch 500, training loss 37.2644
    Epoch 600, training loss 40.6143
    Epoch 700, training loss 81.9176
    Epoch 800, training loss 35.5879
    Epoch 900, training loss 63.7426
    Epoch 1000, training loss 47.3080

학습후의 출력되는 매개변수를 확인합니다.

seqModel.state_dict()['2.weight']

tensor([[-4.3938,  5.7773,  6.0167,  5.4380, -3.8385,  4.9258, -4.9733, -5.6866,
             -4.0214, -6.1506, -5.4964,  4.7211,  6.3179]])

pre=seqModel(x)
pre

tensor([[35.1032],
            [59.9480],
            [60.9743],
            [64.6843],
            [56.6751],
            [52.8242],
            [34.1635],
            [21.3506],
            [45.6800],
            [58.8405],
            [64.0445]], grad_fn=< AddmmBackward >)

import matplotlib.pyplot as plt

plt.figure(dpi=100)
plt.plot(x, y, 'cs', label="observed")
plt.plot(x, pre.detach().numpy(), 'o', label="predicted")
plt.legend(loc='best', prop={'weight':'bold'})
plt.show()

sympy.solvers로 방정식해 구하기

sympy.solvers로 방정식해 구하기 대수 방정식을 해를 계산하기 위해 다음 함수를 사용합니다. sympy.solvers.solve(f, *symbols, **flags) f=0, 즉 동차방정식에 대해 지정한 변수의 해를 계산 f : 식 또는 함수 symbols: 식의 해를 계산하기 위한 변수, 변수가 하나인 경우는 생략가능(자동으로 인식) flags: 계산 또는 결과의 방식을 지정하기 위한 인수들 dict=True: {x:3, y:1}같이 사전형식, 기본값 = False set=True :{(x,3),(y,1)}같이 집합형식, 기본값 = False ratioal=True : 실수를 유리수로 반환, 기본값 = False positive=True: 해들 중에 양수만을 반환, 기본값 = False 예 $x^2=1$의 해를 결정합니다. solve() 함수에 적용하기 위해서는 다음과 같이 식의 한쪽이 0이 되는 형태인 동차식으로 구성되어야 합니다. $$x^2-1=0$$ import numpy as np from sympy import * x = symbols('x') solve(x**2-1, x) [-1, 1] 위 식은 계산 과정은 다음과 같습니다. $$\begin{aligned}x^2-1=0 \rightarrow (x+1)(x-1)=0 \\ x=1 \; \text{or}\; -1\end{aligned}$$ 예 $x^4=1$의 해를 결정합니다. solve() 함수의 인수 set=True를 지정하였으므로 결과는 집합(set)형으로 반환됩니다. eq=x**4-1 solve(eq, set=True) ([x], {(-1,), (-I,), (1,), (I,)}) 위의 경우 I는 복소수입니다.즉 위 결과의 과정은 다음과 같습니다. $$x^4-1=(x^2+1)(x+1)(x-1)=0 \rightarrow x=\pm \sqrt{-1}, \; \pm 1=\pm i,\; \pm1$$ 실수...

sons dataStory

이 블로그 검색

벡터와 행렬에 관련된 그림들